@juspay/neurolink 9.1.1 → 9.2.0

package/dist/lib/utils/fileDetector.js

@@ -3,11 +3,11 @@
  * Centralized file detection for all multimodal file types
  * Uses multi-strategy approach for reliable type identification
  */
-import { request, getGlobalDispatcher, interceptors } from "undici";
 import { readFile, stat } from "fs/promises";
-import { logger } from "./logger.js";
+import { getGlobalDispatcher, interceptors, request } from "undici";
 import { CSVProcessor } from "./csvProcessor.js";
 import { ImageProcessor } from "./imageProcessor.js";
+import { logger } from "./logger.js";
 import { PDFProcessor } from "./pdfProcessor.js";
 /**
  * Default retry configuration constants
@@ -106,7 +106,7 @@ async function withRetry(operation, options = {}) {
                 throw error;
             }
             // Calculate exponential backoff delay
-            const delay = retryDelay * Math.pow(2, attempt);
+            const delay = retryDelay * 2 ** attempt;
             logger.debug("Retrying network operation after transient error", {
                 attempt: attempt + 1,
                 maxRetries,
@@ -186,7 +186,7 @@ export class FileDetector {
      * @returns Processed file result with type and content
      */
     static async detectAndProcess(input, options) {
-        const detection = await this.detect(input, options);
+        const detection = await FileDetector.detect(input, options);
         // FD-018: Comprehensive fallback parsing for extension-less files
         // When file detection returns "unknown" or doesn't match allowedTypes,
         // attempt parsing for each allowed type before failing. This handles cases like Slack
@@ -194,12 +194,12 @@ export class FileDetector {
         if (options?.allowedTypes &&
             !options.allowedTypes.includes(detection.type)) {
             // Try fallback parsing for both "unknown" types and when detection doesn't match allowed types
-            const content = await this.loadContent(input, detection, options);
+            const content = await FileDetector.loadContent(input, detection, options);
             const errors = [];
             // Try each allowed type in order of specificity
             for (const allowedType of options.allowedTypes) {
                 try {
-                    const result = await this.tryFallbackParsing(content, allowedType, options);
+                    const result = await FileDetector.tryFallbackParsing(content, allowedType, options);
                     if (result) {
                         logger.info(`[FileDetector] ✅ ${allowedType.toUpperCase()} fallback successful`);
                         return result;
@@ -214,10 +214,10 @@ export class FileDetector {
             // All fallbacks failed
             throw new Error(`File type detection failed and all fallback parsing attempts failed. Original detection: ${detection.type}. Attempted types: ${options.allowedTypes.join(", ")}. Errors: ${errors.join("; ")}`);
         }
-        const content = await this.loadContent(input, detection, options);
+        const content = await FileDetector.loadContent(input, detection, options);
         // Extract CSV-specific options from FileDetectorOptions
         const csvOptions = options?.csvOptions;
-        return await this.processFile(content, detection, csvOptions, options?.provider);
+        return await FileDetector.processFile(content, detection, csvOptions, options?.provider);
     }
     /**
      * Try fallback parsing for a specific file type
@@ -237,11 +237,11 @@ export class FileDetector {
                 // Try text parsing - check if content is valid UTF-8 text
                 const textContent = content.toString("utf-8");
                 // Validate it's actually text (no null bytes, mostly printable)
-                if (this.isValidText(textContent)) {
+                if (FileDetector.isValidText(textContent)) {
                     return {
                         type: "text",
                         content: textContent,
-                        mimeType: this.guessTextMimeType(textContent),
+                        mimeType: FileDetector.guessTextMimeType(textContent),
                         metadata: {
                             confidence: 70,
                             size: content.length,
@@ -307,7 +307,7 @@ export class FileDetector {
             }
         }
         // Check for XML/HTML using stricter detection
-        if (this.looksLikeXMLStrict(trimmed)) {
+        if (FileDetector.looksLikeXMLStrict(trimmed)) {
             const isHTML = trimmed.includes("<!DOCTYPE html") ||
                 trimmed.toLowerCase().includes("<html") ||
                 trimmed.includes("<head") ||
@@ -315,7 +315,7 @@ export class FileDetector {
             return isHTML ? "text/html" : "application/xml";
         }
         // Check for YAML using robust multi-indicator detection
-        if (this.looksLikeYAMLStrict(trimmed)) {
+        if (FileDetector.looksLikeYAMLStrict(trimmed)) {
             return "application/yaml";
         }
         // Default to plain text
@@ -427,13 +427,13 @@ export class FileDetector {
         }
         switch (source) {
             case "url":
-                return await this.loadFromURL(input, options);
+                return await FileDetector.loadFromURL(input, options);
             case "path":
-                return await this.loadFromPath(input, options);
+                return await FileDetector.loadFromPath(input, options);
             case "buffer":
                 return input;
             case "datauri":
-                return this.loadFromDataURI(input);
+                return FileDetector.loadFromDataURI(input);
             default:
                 throw new Error(`Unknown source: ${source}`);
         }
@@ -454,6 +454,10 @@ export class FileDetector {
                 return await ImageProcessor.process(content);
             case "pdf":
                 return await PDFProcessor.process(content, { provider });
+            case "svg":
+                // SVG is processed as text content (sanitized XML markup)
+                // AI providers don't support SVG as image format, so we extract text content
+                return await FileDetector.processSvgAsText(content, detection);
             case "text":
                 return {
                     type: "text",
@@ -465,12 +469,74 @@ export class FileDetector {
                 throw new Error(`Unsupported file type: ${detection.type}`);
         }
     }
+    /**
+     * Process SVG file as text content
+     * Uses SvgProcessor for security sanitization (removes XSS vectors)
+     * Returns sanitized SVG markup as text for AI analysis
+     */
+    static async processSvgAsText(content, detection) {
+        try {
+            // Dynamic import to avoid circular dependencies
+            const { processSvg } = await import("../processors/markup/SvgProcessor.js");
+            const result = await processSvg({
+                id: "svg-file",
+                name: detection.metadata.filename || "image.svg",
+                mimetype: "image/svg+xml",
+                size: content.length,
+                buffer: content,
+            });
+            if (result.success && result.data) {
+                logger.info(`[FileDetector] SVG processed as text: ${detection.metadata.filename || "image.svg"}`);
+                return {
+                    type: "svg",
+                    content: result.data.textContent, // Sanitized SVG content
+                    mimeType: "image/svg+xml",
+                    metadata: {
+                        confidence: detection.metadata.confidence,
+                        size: content.length,
+                        filename: detection.metadata.filename,
+                        extension: detection.extension,
+                    },
+                };
+            }
+            else {
+                // Fail closed: return safe empty SVG instead of raw unsanitized content
+                logger.warn(`[FileDetector] SVG processor failed, returning safe empty SVG: ${result.error?.userMessage}`);
+                return {
+                    type: "svg",
+                    content: '<svg xmlns="http://www.w3.org/2000/svg"></svg>',
+                    mimeType: "image/svg+xml",
+                    metadata: {
+                        confidence: detection.metadata.confidence,
+                        size: content.length,
+                        filename: detection.metadata.filename,
+                        extension: detection.extension,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            // Fail closed: return safe empty SVG instead of raw unsanitized content
+            logger.warn(`[FileDetector] SVG processor not available, returning safe empty SVG: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                type: "svg",
+                content: '<svg xmlns="http://www.w3.org/2000/svg"></svg>',
+                mimeType: "image/svg+xml",
+                metadata: {
+                    confidence: detection.metadata.confidence,
+                    size: content.length,
+                    filename: detection.metadata.filename,
+                    extension: detection.extension,
+                },
+            };
+        }
+    }
     /**
      * Load file from URL with automatic retry on transient network errors
      */
     static async loadFromURL(url, options) {
         const maxSize = options?.maxSize || 10 * 1024 * 1024;
-        const timeout = options?.timeout || this.DEFAULT_NETWORK_TIMEOUT;
+        const timeout = options?.timeout || FileDetector.DEFAULT_NETWORK_TIMEOUT;
         const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
         const retryDelay = options?.retryDelay ?? DEFAULT_RETRY_DELAY;
         return withRetry(async () => {
@@ -627,6 +693,11 @@ class MimeTypeStrategy {
         if (mime.includes("text/tab-separated-values")) {
             return "csv";
         }
+        // SVG is processed as text/markup, NOT as image
+        // Must check before generic image/ check
+        if (mime.includes("image/svg+xml")) {
+            return "svg";
+        }
         if (mime.includes("image/")) {
             return "image";
         }
@@ -675,7 +746,9 @@ class ExtensionStrategy {
             bmp: "image",
             tiff: "image",
             tif: "image",
-            svg: "image",
+            // SVG is handled as text/markup, NOT as image
+            // AI providers don't support SVG format, so we process it as sanitized text
+            svg: "svg",
             avif: "image",
             pdf: "pdf",
             txt: "text",
@@ -865,7 +938,7 @@ class ContentHeuristicStrategy {
             // (data values like IDs, codes, numbers - not varied content)
             const lengths = lines.map((l) => l.length);
             const avgLength = lengths.reduce((a, b) => a + b, 0) / lengths.length;
-            const variance = lengths.reduce((sum, len) => sum + Math.pow(len - avgLength, 2), 0) /
+            const variance = lengths.reduce((sum, len) => sum + (len - avgLength) ** 2, 0) /
                 lengths.length;
             const stdDev = Math.sqrt(variance);
             // Single-column CSVs can contain varied data (names, cities, emails, etc.)

package/dist/lib/utils/json/extract.d.ts

@@ -0,0 +1,103 @@
+/**
+ * JSON Extraction Utilities
+ *
+ * Utilities for extracting JSON from mixed text content.
+ * Particularly useful for parsing AI responses that contain JSON within prose.
+ */
+/**
+ * Extract JSON string from text that may contain surrounding content.
+ *
+ * Searches for valid JSON in the following order:
+ * 1. Direct parse of the entire text
+ * 2. JSON within markdown code blocks (```json ... ``` or ``` ... ```)
+ * 3. JSON object pattern ({ ... })
+ * 4. JSON array pattern ([ ... ])
+ *
+ * @param text - Text that may contain JSON
+ * @returns Extracted JSON string or null if none found
+ *
+ * @example
+ * ```typescript
+ * const response = "Here's the data: {\"name\": \"test\"} Let me know if you need more.";
+ * const json = extractJsonStringFromText(response);
+ * // Returns: '{"name": "test"}'
+ * ```
+ */
+export declare function extractJsonStringFromText(text: string): string | null;
+/**
+ * Extract and parse JSON from mixed text content.
+ *
+ * Useful for parsing AI responses that contain JSON within prose.
+ * Combines extraction and parsing in one step.
+ *
+ * @param text - Text that may contain JSON
+ * @returns Parsed JSON value or null if not found/invalid
+ *
+ * @example
+ * ```typescript
+ * const response = `
+ *   Here is your configuration:
+ *   \`\`\`json
+ *   {"theme": "dark", "fontSize": 14}
+ *   \`\`\`
+ *   Let me know if you need changes.
+ * `;
+ * const config = extractJsonFromText(response);
+ * // Returns: { theme: "dark", fontSize: 14 }
+ * ```
+ */
+export declare function extractJsonFromText(text: string): unknown | null;
+export type { JsonTypeGuard } from "../../processors/base/types.js";
+import type { JsonTypeGuard } from "../../processors/base/types.js";
+/**
+ * Parse JSON from text with optional type validation.
+ *
+ * Extracts JSON from text and optionally validates it against a type guard.
+ * Useful when you need type-safe parsing of AI responses.
+ *
+ * @param text - Text that may contain JSON
+ * @param validator - Optional type guard to validate the parsed result
+ * @returns Parsed and validated JSON or null if not found/invalid/fails validation
+ *
+ * @example
+ * ```typescript
+ * interface UserConfig {
+ *   theme: string;
+ *   fontSize: number;
+ * }
+ *
+ * function isUserConfig(obj: unknown): obj is UserConfig {
+ *   return (
+ *     typeof obj === 'object' &&
+ *     obj !== null &&
+ *     'theme' in obj &&
+ *     'fontSize' in obj &&
+ *     typeof (obj as UserConfig).theme === 'string' &&
+ *     typeof (obj as UserConfig).fontSize === 'number'
+ *   );
+ * }
+ *
+ * const config = parseJsonFromText<UserConfig>(aiResponse, isUserConfig);
+ * if (config) {
+ *   // config is typed as UserConfig
+ *   console.log(config.theme, config.fontSize);
+ * }
+ * ```
+ */
+export declare function parseJsonFromText<T>(text: string, validator?: JsonTypeGuard<T>): T | null;
+/**
+ * Extract all JSON objects/arrays from text.
+ *
+ * Useful when text contains multiple JSON blocks.
+ *
+ * @param text - Text that may contain multiple JSON values
+ * @returns Array of parsed JSON values
+ *
+ * @example
+ * ```typescript
+ * const text = 'First: {"a": 1} Second: {"b": 2}';
+ * const results = extractAllJsonFromText(text);
+ * // Returns: [{ a: 1 }, { b: 2 }]
+ * ```
+ */
+export declare function extractAllJsonFromText(text: string): unknown[];

package/dist/lib/utils/json/extract.js

@@ -0,0 +1,249 @@
+/**
+ * JSON Extraction Utilities
+ *
+ * Utilities for extracting JSON from mixed text content.
+ * Particularly useful for parsing AI responses that contain JSON within prose.
+ */
+import { parseJsonOrNull } from "./safeParse.js";
+/**
+ * Extract JSON string from text that may contain surrounding content.
+ *
+ * Searches for valid JSON in the following order:
+ * 1. Direct parse of the entire text
+ * 2. JSON within markdown code blocks (```json ... ``` or ``` ... ```)
+ * 3. JSON object pattern ({ ... })
+ * 4. JSON array pattern ([ ... ])
+ *
+ * @param text - Text that may contain JSON
+ * @returns Extracted JSON string or null if none found
+ *
+ * @example
+ * ```typescript
+ * const response = "Here's the data: {\"name\": \"test\"} Let me know if you need more.";
+ * const json = extractJsonStringFromText(response);
+ * // Returns: '{"name": "test"}'
+ * ```
+ */
+export function extractJsonStringFromText(text) {
+    // Try direct parse first - maybe the whole text is valid JSON
+    try {
+        JSON.parse(text);
+        return text;
+    }
+    catch {
+        // Continue to extraction patterns
+    }
+    // Try to find JSON in code blocks (```json ... ``` or ``` ... ```)
+    const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (codeBlockMatch?.[1]) {
+        const potentialJson = codeBlockMatch[1].trim();
+        try {
+            JSON.parse(potentialJson);
+            return potentialJson;
+        }
+        catch {
+            // Continue to other patterns
+        }
+    }
+    // Try to find JSON object or array pattern using non-greedy iterative scan.
+    // Note: [\s\S]*? is non-greedy but can still produce over-spanning matches
+    // in texts with many braces. This is acceptable as we try-parse each candidate
+    // and move to the next on failure. A bracket-balancing parser would be more
+    // precise but significantly more complex for marginal benefit.
+    const candidateRegex = /(\{[\s\S]*?\}|\[[\s\S]*?\])/g;
+    let candidate;
+    while ((candidate = candidateRegex.exec(text)) !== null) {
+        try {
+            JSON.parse(candidate[1]);
+            return candidate[1];
+        }
+        catch {
+            // Try next candidate
+        }
+    }
+    return null;
+}
+/**
+ * Extract and parse JSON from mixed text content.
+ *
+ * Useful for parsing AI responses that contain JSON within prose.
+ * Combines extraction and parsing in one step.
+ *
+ * @param text - Text that may contain JSON
+ * @returns Parsed JSON value or null if not found/invalid
+ *
+ * @example
+ * ```typescript
+ * const response = `
+ *   Here is your configuration:
+ *   \`\`\`json
+ *   {"theme": "dark", "fontSize": 14}
+ *   \`\`\`
+ *   Let me know if you need changes.
+ * `;
+ * const config = extractJsonFromText(response);
+ * // Returns: { theme: "dark", fontSize: 14 }
+ * ```
+ */
+export function extractJsonFromText(text) {
+    const jsonString = extractJsonStringFromText(text);
+    if (!jsonString) {
+        return null;
+    }
+    return parseJsonOrNull(jsonString);
+}
+/**
+ * Parse JSON from text with optional type validation.
+ *
+ * Extracts JSON from text and optionally validates it against a type guard.
+ * Useful when you need type-safe parsing of AI responses.
+ *
+ * @param text - Text that may contain JSON
+ * @param validator - Optional type guard to validate the parsed result
+ * @returns Parsed and validated JSON or null if not found/invalid/fails validation
+ *
+ * @example
+ * ```typescript
+ * interface UserConfig {
+ *   theme: string;
+ *   fontSize: number;
+ * }
+ *
+ * function isUserConfig(obj: unknown): obj is UserConfig {
+ *   return (
+ *     typeof obj === 'object' &&
+ *     obj !== null &&
+ *     'theme' in obj &&
+ *     'fontSize' in obj &&
+ *     typeof (obj as UserConfig).theme === 'string' &&
+ *     typeof (obj as UserConfig).fontSize === 'number'
+ *   );
+ * }
+ *
+ * const config = parseJsonFromText<UserConfig>(aiResponse, isUserConfig);
+ * if (config) {
+ *   // config is typed as UserConfig
+ *   console.log(config.theme, config.fontSize);
+ * }
+ * ```
+ */
+export function parseJsonFromText(text, validator) {
+    const parsed = extractJsonFromText(text);
+    if (parsed === null) {
+        return null;
+    }
+    if (validator && !validator(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+/**
+ * Extract all JSON objects/arrays from text.
+ *
+ * Useful when text contains multiple JSON blocks.
+ *
+ * @param text - Text that may contain multiple JSON values
+ * @returns Array of parsed JSON values
+ *
+ * @example
+ * ```typescript
+ * const text = 'First: {"a": 1} Second: {"b": 2}';
+ * const results = extractAllJsonFromText(text);
+ * // Returns: [{ a: 1 }, { b: 2 }]
+ * ```
+ */
+export function extractAllJsonFromText(text) {
+    const results = [];
+    // Extract from code blocks first
+    const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)```/g;
+    let match = codeBlockRegex.exec(text);
+    while (match !== null) {
+        if (match[1]) {
+            const potentialJson = match[1].trim();
+            try {
+                results.push(JSON.parse(potentialJson));
+            }
+            catch {
+                // Not valid JSON, skip
+            }
+        }
+        match = codeBlockRegex.exec(text);
+    }
+    // If we found code blocks, return those results
+    if (results.length > 0) {
+        return results;
+    }
+    // Otherwise, try to find all JSON objects and arrays
+    // This is a simplified approach - it finds top-level JSON structures
+    const remaining = text;
+    let searchStart = 0;
+    while (searchStart < remaining.length) {
+        // Find next potential JSON start
+        const objectStart = remaining.indexOf("{", searchStart);
+        const arrayStart = remaining.indexOf("[", searchStart);
+        let start;
+        let isObject;
+        if (objectStart === -1 && arrayStart === -1) {
+            break;
+        }
+        else if (objectStart === -1) {
+            start = arrayStart;
+            isObject = false;
+        }
+        else if (arrayStart === -1) {
+            start = objectStart;
+            isObject = true;
+        }
+        else {
+            start = Math.min(objectStart, arrayStart);
+            isObject = objectStart < arrayStart;
+        }
+        // Try to find matching end
+        const openChar = isObject ? "{" : "[";
+        const closeChar = isObject ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escapeNext = false;
+        for (let i = start; i < remaining.length; i++) {
+            const char = remaining[i];
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (char === "\\") {
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString) {
+                continue;
+            }
+            if (char === openChar) {
+                depth++;
+            }
+            else if (char === closeChar) {
+                depth--;
+                if (depth === 0) {
+                    const potentialJson = remaining.substring(start, i + 1);
+                    try {
+                        results.push(JSON.parse(potentialJson));
+                        searchStart = i + 1;
+                    }
+                    catch {
+                        searchStart = start + 1;
+                    }
+                    break;
+                }
+            }
+        }
+        if (depth !== 0) {
+            // Unbalanced brackets, move past this start
+            searchStart = start + 1;
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=extract.js.map

package/dist/lib/utils/json/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * JSON Utilities
+ *
+ * Centralized JSON parsing, serialization, and extraction utilities.
+ * Provides safe operations that handle errors gracefully without throwing.
+ *
+ * @module json
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   safeParseJson,
+ *   parseJsonOrNull,
+ *   isValidJson,
+ *   safeStringify,
+ *   extractJsonFromText,
+ *   parseJsonFromText,
+ * } from './utils/json/index.js';
+ *
+ * // Safe parsing with fallback
+ * const config = safeParseJson(userInput, { theme: 'light' });
+ *
+ * // Check if valid before parsing
+ * if (isValidJson(str)) {
+ *   const data = JSON.parse(str);
+ * }
+ *
+ * // Handle circular references
+ * const json = safeStringify(complexObject, 2);
+ *
+ * // Extract JSON from AI responses
+ * const result = extractJsonFromText(aiResponse);
+ * ```
+ */
+export * from "./extract.js";
+export * from "./safeParse.js";

package/dist/lib/utils/json/index.js

@@ -0,0 +1,37 @@
+/**
+ * JSON Utilities
+ *
+ * Centralized JSON parsing, serialization, and extraction utilities.
+ * Provides safe operations that handle errors gracefully without throwing.
+ *
+ * @module json
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   safeParseJson,
+ *   parseJsonOrNull,
+ *   isValidJson,
+ *   safeStringify,
+ *   extractJsonFromText,
+ *   parseJsonFromText,
+ * } from './utils/json/index.js';
+ *
+ * // Safe parsing with fallback
+ * const config = safeParseJson(userInput, { theme: 'light' });
+ *
+ * // Check if valid before parsing
+ * if (isValidJson(str)) {
+ *   const data = JSON.parse(str);
+ * }
+ *
+ * // Handle circular references
+ * const json = safeStringify(complexObject, 2);
+ *
+ * // Extract JSON from AI responses
+ * const result = extractJsonFromText(aiResponse);
+ * ```
+ */
+export * from "./extract.js";
+export * from "./safeParse.js";
+//# sourceMappingURL=index.js.map