@juspay/neurolink 9.5.3 → 9.7.0

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

@@ -0,0 +1,33 @@
+/**
+ * Archive Processors Module
+ *
+ * Exports archive file processors for ZIP, TAR, TAR.GZ, and GZ formats.
+ * Handles downloading, validating, and extracting file listings from archives
+ * with comprehensive security validation.
+ *
+ * @module processors/archive
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   ArchiveProcessor,
+ *   archiveProcessor,
+ *   isArchiveFile,
+ *   processArchive,
+ *   type ProcessedArchive,
+ *   type ArchiveEntry,
+ *   type ArchiveFormat,
+ * } from "./archive/index.js";
+ *
+ * // Check if a file is an archive
+ * if (isArchiveFile(file.mimetype, file.name)) {
+ *   const result = await processArchive(fileInfo);
+ *   if (result.success) {
+ *     console.log(`Format: ${result.data.archiveMetadata.format}`);
+ *     console.log(`Entries: ${result.data.archiveMetadata.totalEntries}`);
+ *     console.log(result.data.textContent);
+ *   }
+ * }
+ * ```
+ */
+export { type ArchiveEntry, type ArchiveFormat, ArchiveProcessor, archiveProcessor, isArchiveFile, type ProcessedArchive, processArchive, } from "./ArchiveProcessor.js";

package/dist/lib/processors/archive/index.js

@@ -0,0 +1,43 @@
+/**
+ * Archive Processors Module
+ *
+ * Exports archive file processors for ZIP, TAR, TAR.GZ, and GZ formats.
+ * Handles downloading, validating, and extracting file listings from archives
+ * with comprehensive security validation.
+ *
+ * @module processors/archive
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   ArchiveProcessor,
+ *   archiveProcessor,
+ *   isArchiveFile,
+ *   processArchive,
+ *   type ProcessedArchive,
+ *   type ArchiveEntry,
+ *   type ArchiveFormat,
+ * } from "./archive/index.js";
+ *
+ * // Check if a file is an archive
+ * if (isArchiveFile(file.mimetype, file.name)) {
+ *   const result = await processArchive(fileInfo);
+ *   if (result.success) {
+ *     console.log(`Format: ${result.data.archiveMetadata.format}`);
+ *     console.log(`Entries: ${result.data.archiveMetadata.totalEntries}`);
+ *     console.log(result.data.textContent);
+ *   }
+ * }
+ * ```
+ */
+// =============================================================================
+// ARCHIVE PROCESSOR
+// =============================================================================
+export { 
+// Class
+ArchiveProcessor, 
+// Singleton instance
+archiveProcessor, 
+// Helper functions
+isArchiveFile, processArchive, } from "./ArchiveProcessor.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/processors/base/BaseFileProcessor.js

@@ -46,6 +46,7 @@
 import { promisify } from "util";
 import { gunzip } from "zlib";
 import { SIZE_LIMITS } from "../config/index.js";
+import { isAbortError } from "../../utils/errorHandling.js";
 import { createFileError, extractHttpStatus, FileErrorCode, isRetryableError, } from "../errors/index.js";
 import { DEFAULT_RETRY_CONFIG } from "./types.js";
 const gunzipAsync = promisify(gunzip);
@@ -545,7 +546,7 @@ export class BaseFileProcessor {
      * @returns Structured file processing error
      */
     classifyDownloadError(error) {
-        if (error.name === "AbortError") {
+        if (isAbortError(error)) {
             return this.createError(FileErrorCode.DOWNLOAD_TIMEOUT, { timeoutMs: this.config.timeoutMs }, error);
         }
         if (error.message.includes("HTTP")) {

package/dist/lib/processors/base/types.d.ts

@@ -22,7 +22,7 @@ import type { FileErrorCode } from "../errors/FileErrorCode.js";
  * };
  * ```
  */
-export interface FileInfo {
+export type FileInfo = {
     /** Unique identifier for the file */
     id: string;
     /** Original filename */
@@ -37,12 +37,12 @@ export interface FileInfo {
     buffer?: Buffer;
     /** Extensibility - additional provider-specific metadata */
     metadata?: Record<string, unknown>;
-}
+};
 /**
  * Configuration for file processors.
  * Defines constraints and defaults for a specific file type processor.
  */
-export interface FileProcessorConfig {
+export type FileProcessorConfig = {
     /** Maximum file size in megabytes */
     maxSizeMB: number;
     /** Download/processing timeout in milliseconds */
@@ -55,12 +55,12 @@ export interface FileProcessorConfig {
     fileTypeName: string;
     /** Default filename when original name is not available */
     defaultFilename: string;
-}
+};
 /**
  * Base interface for processed file data.
  * All specific processed types should extend this interface.
  */
-export interface ProcessedFileBase {
+export type ProcessedFileBase = {
     /** File content as a Buffer */
     buffer: Buffer;
     /** MIME type of the processed content */
@@ -69,12 +69,12 @@ export interface ProcessedFileBase {
     size: number;
     /** Filename (may be normalized or sanitized) */
     filename: string;
-}
+};
 /**
  * Structured file processing error with user-friendly messaging.
  * This is the canonical error type used across all processor infrastructure.
  */
-export interface FileProcessingError {
+export type FileProcessingError = {
     /** Error code from FileErrorCode enum */
     code: FileErrorCode | string;
     /** Technical error message */
@@ -91,19 +91,19 @@ export interface FileProcessingError {
     technicalDetails?: string;
     /** Original error that caused this failure */
     originalError?: Error;
-}
+};
 /**
  * Generic result type for internal operations.
  * Used for validation and download operations that don't return ProcessedFileBase.
  */
-export interface OperationResult<T = void> {
+export type OperationResult<T = void> = {
     /** Whether the operation was successful */
     success: boolean;
     /** Operation result data (present when success is true) */
     data?: T;
     /** Error information (present when success is false) */
     error?: FileProcessingError;
-}
+};
 /**
  * Result of a file processing operation.
  * Uses discriminated union pattern for type-safe error handling.
@@ -118,19 +118,19 @@ export interface OperationResult<T = void> {
  * }
  * ```
  */
-export interface FileProcessingResult<T extends ProcessedFileBase = ProcessedFileBase> {
+export type FileProcessingResult<T extends ProcessedFileBase = ProcessedFileBase> = {
     /** Whether the processing was successful */
     success: boolean;
     /** Processed file data (present when success is true) */
     data?: T;
     /** Error information (present when success is false) */
     error?: FileProcessingError;
-}
+};
 /**
  * Configuration for retry behavior on transient failures.
  * Implements exponential backoff with optional custom retry predicate.
  */
-export interface RetryConfig {
+export type RetryConfig = {
     /** Maximum number of retry attempts */
     maxRetries: number;
     /** Base delay between retries in milliseconds */
@@ -139,19 +139,19 @@ export interface RetryConfig {
     maxDelayMs: number;
     /** Optional custom function to determine if an error is retryable */
     retryOn?: (error: Error) => boolean;
-}
+};
 /**
  * Options for file processing operations.
  * Allows customization of download behavior and retry logic.
  */
-export interface ProcessOptions {
+export type ProcessOptions = {
     /** Authentication headers for download requests */
     authHeaders?: Record<string, string>;
     /** Override default timeout (in milliseconds) */
     timeout?: number;
     /** Retry configuration for transient failures */
     retryConfig?: RetryConfig;
-}
+};
 /**
  * Default retry configuration for file downloads.
  * Uses exponential backoff: 1s, 2s, 4s (capped at maxDelayMs)
@@ -168,7 +168,7 @@ export declare const DEFAULT_IMAGE_MAX_SIZE_MB = 10;
 /**
  * Information about a successfully processed file.
  */
-export interface ProcessedFileInfo {
+export type ProcessedFileInfo = {
     /** File identifier */
     fileId: string;
     /** Filename */
@@ -179,11 +179,11 @@ export interface ProcessedFileInfo {
     size: number;
     /** Type of processor used */
     processorType: string;
-}
+};
 /**
  * Information about a file that failed to process.
  */
-export interface FailedFileInfo {
+export type FailedFileInfo = {
     /** File identifier */
     fileId: string;
     /** Filename */
@@ -194,11 +194,11 @@ export interface FailedFileInfo {
     size: number;
     /** Error that caused the failure */
     error: FileProcessingError;
-}
+};
 /**
  * Information about a file that was skipped.
  */
-export interface SkippedFileInfo {
+export type SkippedFileInfo = {
     /** File identifier */
     fileId: string;
     /** Filename */
@@ -211,22 +211,22 @@ export interface SkippedFileInfo {
     reason: string;
     /** Suggested alternative action */
     suggestedAlternative?: string;
-}
+};
 /**
  * Warning about a file (non-fatal issue).
  */
-export interface FileWarning {
+export type FileWarning = {
     /** File identifier */
     fileId: string;
     /** Filename */
     filename: string;
     /** Warning message */
     message: string;
-}
+};
 /**
  * Summary of batch file processing operations.
  */
-export interface BatchProcessingSummary<T extends ProcessedFileBase = ProcessedFileBase> {
+export type BatchProcessingSummary<T extends ProcessedFileBase = ProcessedFileBase> = {
     /** Total number of files attempted */
     totalFiles: number;
     /** Successfully processed files */
@@ -239,7 +239,7 @@ export interface BatchProcessingSummary<T extends ProcessedFileBase = ProcessedF
     warnings: FileWarning[];
     /** Processed results (parallel array with processedFiles) */
     results: T[];
-}
+};
 /**
  * Result of finding a matching processor for a file.
  * Includes both the processor and metadata about the match quality.
@@ -247,7 +247,7 @@ export interface BatchProcessingSummary<T extends ProcessedFileBase = ProcessedF
  * Note: `processor` is typed as `unknown` here to avoid circular dependency
  * on BaseFileProcessor. The registry module uses the properly typed version.
  */
-export interface ProcessorMatch<_T extends ProcessedFileBase = ProcessedFileBase> {
+export type ProcessorMatch<_T extends ProcessedFileBase = ProcessedFileBase> = {
     /** Name of the matched processor */
     name: string;
     /** The processor instance */
@@ -263,12 +263,12 @@ export interface ProcessorMatch<_T extends ProcessedFileBase = ProcessedFileBase
      * - 40: Generic/fallback match
      */
     confidence: number;
-}
+};
 /**
  * Options for registry operations.
  * Controls behavior when registering processors.
  */
-export interface RegistryOptions {
+export type RegistryOptions = {
     /**
      * Allow registering processors with duplicate names.
      * If false (default), an error is thrown on duplicate names.
@@ -279,12 +279,12 @@ export interface RegistryOptions {
      * Takes precedence over allowDuplicates.
      */
     overwriteExisting?: boolean;
-}
+};
 /**
  * Detailed error information for unsupported file types.
  * Provides helpful suggestions for the user.
  */
-export interface UnsupportedFileError {
+export type UnsupportedFileError = {
     /** Error code for programmatic handling */
     code: "NO_PROCESSOR_FOUND" | "PROCESSING_FAILED";
     /** Human-readable error message */
@@ -297,19 +297,19 @@ export interface UnsupportedFileError {
     suggestion: string;
     /** List of supported file types */
     supportedTypes: string[];
-}
+};
 /**
  * Result of processing a file through the registry.
  * Includes type information for tracking which processor was used.
  */
-export interface RegistryProcessResult<T = unknown> {
+export type RegistryProcessResult<T = unknown> = {
     /** Type/name of the processor that handled the file */
     type: string;
     /** Processed data (null if processing failed) */
     data: T | null;
     /** Error information if processing failed */
     error?: UnsupportedFileError;
-}
+};
 /**
  * Priority levels for file processors.
  * Lower number = higher priority = matched first.
@@ -354,6 +354,12 @@ export declare const PROCESSOR_PRIORITIES: {
     readonly RTF: 140;
     /** OpenDocument format files */
     readonly OPENDOCUMENT: 150;
+    /** Video files */
+    readonly VIDEO: 160;
+    /** Audio files */
+    readonly AUDIO: 170;
+    /** Archive files */
+    readonly ARCHIVE: 180;
 };
 /**
  * Type for processor priority keys
@@ -367,7 +373,7 @@ export type ProcessorPriorityValue = (typeof PROCESSOR_PRIORITIES)[ProcessorPrio
  * Information about a registered processor.
  * Used for discovery and documentation.
  */
-export interface ProcessorInfo {
+export type ProcessorInfo = {
     /** Unique name for the processor */
     name: string;
     /** Human-readable description */
@@ -378,7 +384,7 @@ export interface ProcessorInfo {
     supportedExtensions: string[];
     /** Priority level (lower = higher priority) */
     priority?: number;
-}
+};
 /**
  * Error message template with user-friendly messaging and retry information.
  * Re-exported from errors module for convenience.
@@ -388,7 +394,7 @@ export type { ErrorMessageTemplate, FileErrorCode, } from "../errors/FileErrorCo
  * Processed SVG result.
  * Extends ProcessedFileBase with SVG-specific fields.
  */
-export interface ProcessedSvg extends ProcessedFileBase {
+export type ProcessedSvg = ProcessedFileBase & {
     /** Sanitized SVG content as text for AI processing */
     textContent: string;
     /** Original raw content (only included if sanitization modified the content) */
@@ -397,11 +403,11 @@ export interface ProcessedSvg extends ProcessedFileBase {
     sanitized: boolean;
     /** Security warnings found during processing */
     securityWarnings: string[];
-}
+};
 /**
  * Processed XML file result.
  */
-export interface ProcessedXml extends ProcessedFileBase {
+export type ProcessedXml = ProcessedFileBase & {
     /** Original XML content */
     content: string;
     /** Parsed XML content (as JavaScript object) */
@@ -412,11 +418,11 @@ export interface ProcessedXml extends ProcessedFileBase {
     errorMessage?: string;
     /** Name of the root element */
     rootElement?: string;
-}
+};
 /**
  * Processed Markdown result.
  */
-export interface ProcessedMarkdown extends ProcessedFileBase {
+export type ProcessedMarkdown = ProcessedFileBase & {
     /** Original Markdown content */
     content: string;
     /** Total number of lines in the document */
@@ -427,11 +433,11 @@ export interface ProcessedMarkdown extends ProcessedFileBase {
     hasTables: boolean;
     /** List of headings extracted from the document */
     headings: string[];
-}
+};
 /**
  * Processed source code result.
  */
-export interface ProcessedSourceCode extends ProcessedFileBase {
+export type ProcessedSourceCode = ProcessedFileBase & {
     /** The source code content (may be truncated) */
     content: string;
     /** Detected programming language (e.g., "TypeScript", "Python") */
@@ -442,11 +448,11 @@ export interface ProcessedSourceCode extends ProcessedFileBase {
     truncated: boolean;
     /** Character encoding used to decode the file */
     encoding: string;
-}
+};
 /**
  * Processed configuration file result.
  */
-export interface ProcessedConfig extends ProcessedFileBase {
+export type ProcessedConfig = ProcessedFileBase & {
     /** The configuration file content with redacted sensitive values */
     content: string;
     /** Detected configuration format */
@@ -455,11 +461,11 @@ export interface ProcessedConfig extends ProcessedFileBase {
     keyValues: Record<string, string>;
     /** List of keys that were redacted for security */
     redactedKeys: string[];
-}
+};
 /**
  * Processed OpenDocument result.
  */
-export interface ProcessedOpenDocument extends ProcessedFileBase {
+export type ProcessedOpenDocument = ProcessedFileBase & {
     /** Extracted text content */
     textContent: string;
     /** Document format type */
@@ -468,11 +474,11 @@ export interface ProcessedOpenDocument extends ProcessedFileBase {
     paragraphCount: number;
     /** Whether content was truncated */
     truncated: boolean;
-}
+};
 /**
  * Processed JSON file result.
  */
-export interface ProcessedJson extends ProcessedFileBase {
+export type ProcessedJson = ProcessedFileBase & {
     /** Pretty-printed JSON content (or original content if invalid) */
     content: string;
     /** Original raw content before pretty-printing */
@@ -489,11 +495,11 @@ export interface ProcessedJson extends ProcessedFileBase {
     arrayLength?: number;
     /** Whether content was truncated */
     truncated: boolean;
-}
+};
 /**
  * Processed plain text file result.
  */
-export interface ProcessedText extends ProcessedFileBase {
+export type ProcessedText = ProcessedFileBase & {
     /** Text content (may be truncated if file is too large) */
     content: string;
     /** Total number of lines in the original file */
@@ -504,11 +510,11 @@ export interface ProcessedText extends ProcessedFileBase {
     encoding: string;
     /** Whether the content was truncated due to size limits */
     truncated: boolean;
-}
+};
 /**
  * Processed HTML file result.
  */
-export interface ProcessedHtml extends ProcessedFileBase {
+export type ProcessedHtml = ProcessedFileBase & {
     /** Original HTML content */
     content: string;
     /** Text extracted from HTML (all tags stripped) */
@@ -521,11 +527,11 @@ export interface ProcessedHtml extends ProcessedFileBase {
     title?: string;
     /** Whether the HTML contains potentially dangerous content (XSS vectors) */
     hasDangerousContent: boolean;
-}
+};
 /**
  * Processed YAML file result.
  */
-export interface ProcessedYaml extends ProcessedFileBase {
+export type ProcessedYaml = ProcessedFileBase & {
     /** Original YAML content */
     content: string;
     /** Parsed YAML content (as JavaScript object) */
@@ -536,11 +542,11 @@ export interface ProcessedYaml extends ProcessedFileBase {
     errorMessage?: string;
     /** YAML content converted to JSON string for AI consumption */
     asJson: string | null;
-}
+};
 /**
  * Single worksheet extracted from an Excel file.
  */
-export interface ExcelWorksheet {
+export type ExcelWorksheet = {
     /** Name of the worksheet (tab name in Excel) */
     name: string;
     /** Row data as a 2D array. Each inner array represents a row. */
@@ -551,11 +557,11 @@ export interface ExcelWorksheet {
     rowCount: number;
     /** Number of columns (based on headers or first row) */
     columnCount: number;
-}
+};
 /**
  * Processed Excel file result.
  */
-export interface ProcessedExcel extends ProcessedFileBase {
+export type ProcessedExcel = ProcessedFileBase & {
     /** Array of processed worksheets */
     worksheets: ExcelWorksheet[];
     /** Number of sheets processed (may be less than total if truncated) */
@@ -566,27 +572,27 @@ export interface ProcessedExcel extends ProcessedFileBase {
     truncated: boolean;
     /** Names of sheets that were truncated */
     truncatedSheets: string[];
-}
+};
 /**
  * Processed Word document result.
  */
-export interface ProcessedWord extends ProcessedFileBase {
+export type ProcessedWord = ProcessedFileBase & {
     /** Extracted plain text content from the Word document */
     textContent: string;
     /** HTML representation of the Word document */
     htmlContent: string;
     /** Warnings from mammoth extraction (e.g., unsupported elements) */
     warnings: string[];
-}
+};
 /**
  * Processed RTF document result.
  */
-export interface ProcessedRtf extends ProcessedFileBase {
+export type ProcessedRtf = ProcessedFileBase & {
     /** Extracted plain text content from the RTF document */
     textContent: string;
     /** Raw RTF content (preserved for debugging/analysis) */
     rawContent: string;
-}
+};
 /**
  * Type guard function signature for JSON parsing.
  */

package/dist/lib/processors/base/types.js

@@ -73,5 +73,11 @@ export const PROCESSOR_PRIORITIES = {
     RTF: 140,
     /** OpenDocument format files */
     OPENDOCUMENT: 150,
+    /** Video files */
+    VIDEO: 160,
+    /** Audio files */
+    AUDIO: 170,
+    /** Archive files */
+    ARCHIVE: 180,
 };
 //# sourceMappingURL=types.js.map

package/dist/lib/processors/cli/fileProcessorCli.d.ts

@@ -32,18 +32,18 @@ import type { FileInfo } from "../base/types.js";
 /**
  * Options for CLI file processing
  */
-export interface CliFileProcessingOptions {
+export type CliFileProcessingOptions = {
     /** Verbose output - shows processing details */
     verbose?: boolean;
     /** Processor to use (bypasses auto-detection) */
     processor?: string;
     /** Output format: json, text, or raw */
     outputFormat?: "json" | "text" | "raw";
-}
+};
 /**
  * Result of CLI file processing
  */
-export interface CliProcessingResult {
+export type CliProcessingResult = {
     /** Whether processing succeeded */
     success: boolean;
     /** Name of the processor that was used */
@@ -52,11 +52,11 @@ export interface CliProcessingResult {
     output: string;
     /** Error message if processing failed */
     error?: string;
-}
+};
 /**
  * Information about a supported file type
  */
-export interface SupportedFileTypeInfo {
+export type SupportedFileTypeInfo = {
     /** Processor name */
     name: string;
     /** Priority (lower = processed first) */
@@ -67,7 +67,7 @@ export interface SupportedFileTypeInfo {
     mimeTypes: string[];
     /** Optional description */
     description?: string;
-}
+};
 /**
  * Load a file from the filesystem and create a FileInfo object.
  *
@@ -117,7 +117,7 @@ export declare function processFileFromPath(filePath: string, options?: CliFileP
  * }
  * ```
  */
-export declare function getSupportedFileTypes(): SupportedFileTypeInfo[];
+export declare function getSupportedFileTypes(): Promise<SupportedFileTypeInfo[]>;
 /**
  * List all supported file types formatted for CLI display.
  *
@@ -128,7 +128,7 @@ export declare function getSupportedFileTypes(): SupportedFileTypeInfo[];
  * console.log(listSupportedFileTypes());
  * ```
  */
-export declare function listSupportedFileTypes(): string;
+export declare function listSupportedFileTypes(): Promise<string>;
 /**
  * Get CLI usage information for file processing commands.
  *

package/dist/lib/processors/cli/fileProcessorCli.js

@@ -114,7 +114,7 @@ export async function processFileFromPath(filePath, options) {
             logger.info(`  Size: ${fileInfo.size} bytes`);
             logger.info(`  MIME: ${fileInfo.mimetype}`);
         }
-        const registry = getProcessorRegistry();
+        const registry = await getProcessorRegistry();
         // If a specific processor is requested, use it directly
         if (options?.processor) {
             const processorReg = registry.getProcessor(options.processor);
@@ -248,8 +248,8 @@ function formatOutput(data, format) {
  * }
  * ```
  */
-export function getSupportedFileTypes() {
-    const registry = getProcessorRegistry();
+export async function getSupportedFileTypes() {
+    const registry = await getProcessorRegistry();
     const processors = registry.listProcessors();
     return processors.map((proc) => {
         // Extract config from processor via public getConfig() method
@@ -273,8 +273,8 @@ export function getSupportedFileTypes() {
  * console.log(listSupportedFileTypes());
  * ```
  */
-export function listSupportedFileTypes() {
-    const types = getSupportedFileTypes();
+export async function listSupportedFileTypes() {
+    const types = await getSupportedFileTypes();
     if (types.length === 0) {
         return "No processors registered. Initialize the processor registry first.";
     }