@juspay/neurolink 7.48.0 → 7.49.0

package/dist/utils/fileDetector.js

@@ -0,0 +1,457 @@
+/**
+ * File Type Detection Utility
+ * Centralized file detection for all multimodal file types
+ * Uses multi-strategy approach for reliable type identification
+ */
+import { request } from "undici";
+import { readFile, stat } from "fs/promises";
+import { logger } from "./logger.js";
+import { CSVProcessor } from "./csvProcessor.js";
+import { ImageProcessor } from "./imageProcessor.js";
+/**
+ * Format file size in human-readable units
+ */
+function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} bytes`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    }
+    if (bytes < 1024 * 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    }
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+/**
+ * Centralized file type detection and processing
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect and process any file
+ * const result = await FileDetector.detectAndProcess("data.csv");
+ * console.log(result.type); // 'csv'
+ * ```
+ */
+export class FileDetector {
+    /**
+     * Auto-detect file type and process in one call
+     *
+     * Runs detection strategies in priority order:
+     * 1. MagicBytesStrategy (95% confidence) - Binary file headers
+     * 2. MimeTypeStrategy (85% confidence) - HTTP Content-Type for URLs
+     * 3. ExtensionStrategy (70% confidence) - File extension
+     * 4. ContentHeuristicStrategy (75% confidence) - Content analysis
+     *
+     * @param input - File path, URL, Buffer, or data URI
+     * @param options - Detection and processing options
+     * @returns Processed file result with type and content
+     */
+    static async detectAndProcess(input, options) {
+        const detection = await this.detect(input, options);
+        if (options?.allowedTypes &&
+            !options.allowedTypes.includes(detection.type)) {
+            throw new Error(`File type ${detection.type} not allowed. Allowed: ${options.allowedTypes.join(", ")}`);
+        }
+        const content = await this.loadContent(input, detection, options);
+        // Extract CSV-specific options from FileDetectorOptions
+        const csvOptions = options?.csvOptions;
+        return await this.processFile(content, detection, csvOptions);
+    }
+    /**
+     * Detect file type using multi-strategy approach
+     * Stops at first strategy with confidence >= threshold (default: 80%)
+     */
+    static async detect(input, options) {
+        const confidenceThreshold = options?.confidenceThreshold ?? 80;
+        const strategies = [
+            new MagicBytesStrategy(),
+            new MimeTypeStrategy(),
+            new ExtensionStrategy(),
+            new ContentHeuristicStrategy(),
+        ];
+        let best = null;
+        for (const strategy of strategies) {
+            const result = await strategy.detect(input);
+            if (!best || result.metadata.confidence > best.metadata.confidence) {
+                best = result;
+            }
+            if (result.metadata.confidence >= confidenceThreshold) {
+                logger.info(`[FileDetector] Type: ${result.type} (${result.metadata.confidence}%)`);
+                return result;
+            }
+        }
+        logger.warn(`[FileDetector] Low confidence: ${best?.type ?? "unknown"} (${best?.metadata.confidence ?? 0}%)`);
+        return best;
+    }
+    /**
+     * Load file content from various sources
+     */
+    static async loadContent(input, detection, options) {
+        let source = detection.source;
+        if (source === "buffer" && !Buffer.isBuffer(input)) {
+            if (typeof input === "string") {
+                if (input.startsWith("data:")) {
+                    source = "datauri";
+                }
+                else if (input.startsWith("http://") ||
+                    input.startsWith("https://")) {
+                    source = "url";
+                }
+                else {
+                    source = "path";
+                }
+            }
+        }
+        switch (source) {
+            case "url":
+                return await this.loadFromURL(input, options);
+            case "path":
+                return await this.loadFromPath(input, options);
+            case "buffer":
+                return input;
+            case "datauri":
+                return this.loadFromDataURI(input);
+            default:
+                throw new Error(`Unknown source: ${source}`);
+        }
+    }
+    /**
+     * Route to appropriate processor
+     */
+    static async processFile(content, detection, options) {
+        switch (detection.type) {
+            case "csv":
+                return await CSVProcessor.process(content, options);
+            case "image":
+                return await ImageProcessor.process(content);
+            case "text":
+                return {
+                    type: "text",
+                    content: content.toString("utf-8"),
+                    mimeType: "text/plain",
+                    metadata: detection.metadata,
+                };
+            default:
+                throw new Error(`Unsupported file type: ${detection.type}`);
+        }
+    }
+    /**
+     * Load file from URL
+     */
+    static async loadFromURL(url, options) {
+        const maxSize = options?.maxSize || 10 * 1024 * 1024;
+        const timeout = options?.timeout || 30000;
+        const response = await request(url, {
+            method: "GET",
+            headersTimeout: timeout,
+            bodyTimeout: timeout,
+            maxRedirections: 5,
+        });
+        if (response.statusCode !== 200) {
+            throw new Error(`HTTP ${response.statusCode}`);
+        }
+        const chunks = [];
+        let totalSize = 0;
+        for await (const chunk of response.body) {
+            totalSize += chunk.length;
+            if (totalSize > maxSize) {
+                throw new Error(`File too large: ${formatFileSize(totalSize)} (max: ${formatFileSize(maxSize)})`);
+            }
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    /**
+     * Load file from filesystem path
+     */
+    static async loadFromPath(path, options) {
+        const maxSize = options?.maxSize || 10 * 1024 * 1024;
+        const statInfo = await stat(path);
+        if (!statInfo.isFile()) {
+            throw new Error("Not a file");
+        }
+        if (statInfo.size > maxSize) {
+            throw new Error(`File too large: ${formatFileSize(statInfo.size)} (max: ${formatFileSize(maxSize)})`);
+        }
+        return await readFile(path);
+    }
+    /**
+     * Load file from data URI
+     */
+    static loadFromDataURI(dataUri) {
+        const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
+        if (!match) {
+            throw new Error("Invalid data URI format");
+        }
+        return Buffer.from(match[2], "base64");
+    }
+}
+/**
+ * Strategy 1: Magic Bytes Detection (95% confidence)
+ * Detects file type from binary file headers
+ */
+class MagicBytesStrategy {
+    async detect(input) {
+        if (!Buffer.isBuffer(input)) {
+            return this.unknown();
+        }
+        if (this.isPNG(input)) {
+            return this.result("image", "image/png", 95);
+        }
+        if (this.isJPEG(input)) {
+            return this.result("image", "image/jpeg", 95);
+        }
+        if (this.isGIF(input)) {
+            return this.result("image", "image/gif", 95);
+        }
+        if (this.isWebP(input)) {
+            return this.result("image", "image/webp", 95);
+        }
+        if (this.isPDF(input)) {
+            return this.result("pdf", "application/pdf", 95);
+        }
+        return this.unknown();
+    }
+    isPNG(buf) {
+        return (buf.length >= 4 &&
+            buf[0] === 0x89 &&
+            buf[1] === 0x50 &&
+            buf[2] === 0x4e &&
+            buf[3] === 0x47);
+    }
+    isJPEG(buf) {
+        return (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff);
+    }
+    isGIF(buf) {
+        return (buf.length >= 4 &&
+            buf[0] === 0x47 &&
+            buf[1] === 0x49 &&
+            buf[2] === 0x46 &&
+            buf[3] === 0x38);
+    }
+    isWebP(buf) {
+        return (buf.length >= 12 &&
+            buf.slice(0, 4).toString() === "RIFF" &&
+            buf.slice(8, 12).toString() === "WEBP");
+    }
+    isPDF(buf) {
+        return buf.length >= 5 && buf.slice(0, 5).toString() === "%PDF-";
+    }
+    result(type, mime, confidence) {
+        return {
+            type,
+            mimeType: mime,
+            extension: null,
+            source: "buffer",
+            metadata: { confidence },
+        };
+    }
+    unknown() {
+        return {
+            type: "unknown",
+            mimeType: "application/octet-stream",
+            extension: null,
+            source: "buffer",
+            metadata: { confidence: 0 },
+        };
+    }
+}
+/**
+ * Strategy 2: MIME Type Detection (85% confidence)
+ * Detects file type from HTTP Content-Type headers
+ */
+class MimeTypeStrategy {
+    async detect(input) {
+        if (typeof input !== "string" || !this.isURL(input)) {
+            return this.unknown();
+        }
+        try {
+            const response = await request(input, {
+                method: "HEAD",
+                headersTimeout: 5000,
+                bodyTimeout: 5000,
+                maxRedirections: 5,
+            });
+            const contentType = response.headers["content-type"] || "";
+            const type = this.mimeToFileType(contentType);
+            return {
+                type,
+                mimeType: contentType.split(";")[0].trim(),
+                extension: null,
+                source: "url",
+                metadata: { confidence: type !== "unknown" ? 85 : 0 },
+            };
+        }
+        catch {
+            return this.unknown();
+        }
+    }
+    mimeToFileType(mime) {
+        if (mime.includes("text/csv")) {
+            return "csv";
+        }
+        if (mime.includes("text/tab-separated-values")) {
+            return "csv";
+        }
+        if (mime.includes("image/")) {
+            return "image";
+        }
+        if (mime.includes("application/pdf")) {
+            return "pdf";
+        }
+        if (mime.includes("text/plain")) {
+            return "text";
+        }
+        return "unknown";
+    }
+    isURL(str) {
+        return str.startsWith("http://") || str.startsWith("https://");
+    }
+    unknown() {
+        return {
+            type: "unknown",
+            mimeType: "application/octet-stream",
+            extension: null,
+            source: "buffer",
+            metadata: { confidence: 0 },
+        };
+    }
+}
+/**
+ * Strategy 3: Extension Detection (70% confidence)
+ * Detects file type from file extension
+ */
+class ExtensionStrategy {
+    async detect(input) {
+        if (typeof input !== "string") {
+            return this.unknown();
+        }
+        const ext = this.getExtension(input);
+        if (!ext) {
+            return this.unknown();
+        }
+        const typeMap = {
+            csv: "csv",
+            tsv: "csv",
+            jpg: "image",
+            jpeg: "image",
+            png: "image",
+            gif: "image",
+            webp: "image",
+            bmp: "image",
+            tiff: "image",
+            tif: "image",
+            svg: "image",
+            avif: "image",
+            pdf: "pdf",
+            txt: "text",
+            md: "text",
+        };
+        const type = typeMap[ext.toLowerCase()];
+        return {
+            type: type || "unknown",
+            mimeType: this.getMimeType(ext),
+            extension: ext,
+            source: this.detectSource(input),
+            metadata: { confidence: type ? 70 : 0 },
+        };
+    }
+    getExtension(input) {
+        if (this.isURL(input)) {
+            const url = new URL(input);
+            const match = url.pathname.match(/\.([^.]+)$/);
+            return match ? match[1] : null;
+        }
+        const match = input.match(/\.([^.]+)$/);
+        return match ? match[1] : null;
+    }
+    isURL(str) {
+        return str.startsWith("http://") || str.startsWith("https://");
+    }
+    detectSource(input) {
+        if (input.startsWith("data:")) {
+            return "datauri";
+        }
+        if (this.isURL(input)) {
+            return "url";
+        }
+        return "path";
+    }
+    getMimeType(ext) {
+        const mimeMap = {
+            csv: "text/csv",
+            tsv: "text/tab-separated-values",
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            png: "image/png",
+            gif: "image/gif",
+            webp: "image/webp",
+            bmp: "image/bmp",
+            tiff: "image/tiff",
+            tif: "image/tiff",
+            svg: "image/svg+xml",
+            avif: "image/avif",
+            pdf: "application/pdf",
+            txt: "text/plain",
+            md: "text/markdown",
+        };
+        return mimeMap[ext.toLowerCase()] || "application/octet-stream";
+    }
+    unknown() {
+        return {
+            type: "unknown",
+            mimeType: "application/octet-stream",
+            extension: null,
+            source: "buffer",
+            metadata: { confidence: 0 },
+        };
+    }
+}
+/**
+ * Strategy 4: Content Heuristics (75% confidence)
+ * Detects file type by analyzing content patterns
+ */
+class ContentHeuristicStrategy {
+    async detect(input) {
+        if (!Buffer.isBuffer(input)) {
+            return this.unknown();
+        }
+        const sample = input.toString("utf-8", 0, Math.min(1000, input.length));
+        if (this.looksLikeCSV(sample)) {
+            return this.result("csv", "text/csv", 75);
+        }
+        return this.unknown();
+    }
+    looksLikeCSV(text) {
+        const lines = text.split("\n").slice(0, 5);
+        if (lines.length < 2) {
+            return false;
+        }
+        const hasCommas = lines.every((line) => line.includes(","));
+        if (!hasCommas) {
+            return false;
+        }
+        const columnCounts = lines.map((line) => line.split(",").length);
+        const uniqueCounts = new Set(columnCounts);
+        return uniqueCounts.size === 1 && columnCounts[0] >= 2;
+    }
+    result(type, mime, confidence) {
+        return {
+            type,
+            mimeType: mime,
+            extension: null,
+            source: "buffer",
+            metadata: { confidence },
+        };
+    }
+    unknown() {
+        return {
+            type: "unknown",
+            mimeType: "application/octet-stream",
+            extension: null,
+            source: "buffer",
+            metadata: { confidence: 0 },
+        };
+    }
+}

package/dist/utils/imageProcessor.d.ts

@@ -3,10 +3,20 @@
  * Handles format conversion for different AI providers
  */
 import type { ProcessedImage } from "../types/content.js";
+import type { FileProcessingResult } from "../types/fileTypes.js";
 /**
  * Image processor class for handling provider-specific image formatting
  */
 export declare class ImageProcessor {
+    /**
+     * Process image Buffer (unified interface)
+     * Matches CSVProcessor.process() signature for consistency
+     *
+     * @param content - Image file as Buffer
+     * @param options - Processing options (unused for now)
+     * @returns Processed image as data URI
+     */
+    static process(content: Buffer, _options?: unknown): Promise<FileProcessingResult>;
     /**
      * Process image for OpenAI (requires data URI format)
      */

package/dist/utils/imageProcessor.js

@@ -7,6 +7,28 @@ import { logger } from "./logger.js";
  * Image processor class for handling provider-specific image formatting
  */
 export class ImageProcessor {
+    /**
+     * Process image Buffer (unified interface)
+     * Matches CSVProcessor.process() signature for consistency
+     *
+     * @param content - Image file as Buffer
+     * @param options - Processing options (unused for now)
+     * @returns Processed image as data URI
+     */
+    static async process(content, _options) {
+        const mediaType = this.detectImageType(content);
+        const base64 = content.toString("base64");
+        const dataUri = `data:${mediaType};base64,${base64}`;
+        return {
+            type: "image",
+            content: dataUri,
+            mimeType: mediaType,
+            metadata: {
+                confidence: 100,
+                size: content.length,
+            },
+        };
+    }
     /**
      * Process image for OpenAI (requires data URI format)
      */

package/dist/utils/loopUtils.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Loop Mode Utilities
+ * Utilities specific to CLI loop mode session management and restoration
+ */
+import type { ChatMessage, ConversationData } from "../types/conversation.js";
+import type { SessionRestoreResult } from "../types/cli.js";
+/**
+ * Verify that conversation context is accessible and properly loaded
+ * Uses the global session to access the NeuroLink instance
+ */
+export declare function verifyConversationContext(sessionId: string): Promise<void>;
+/**
+ * Get conversation context for display (first few and last few messages)
+ * Uses the global session to access the NeuroLink instance
+ */
+export declare function getConversationPreview(sessionId: string, previewCount?: number): Promise<ChatMessage[]>;
+/**
+ * Generate a title from content by truncating to appropriate length
+ */
+export declare function generateConversationTitle(content: string): string;
+/**
+ * Truncate text content to specified length with ellipsis
+ */
+export declare function truncateText(content: string, maxLength: number): string;
+/**
+ * Format timestamp as human-readable relative time
+ * Uses Intl.RelativeTimeFormat for natural language output
+ */
+export declare function formatTimeAgo(timestamp: string): string;
+/**
+ * Get appropriate icon for content based on regex patterns
+ */
+export declare function getContentIcon(content: string): string;
+/**
+ * Display session restoration status message
+ */
+export declare function displaySessionMessage(result: SessionRestoreResult): void;
+/**
+ * Load command history from the global history file
+ */
+export declare function loadCommandHistory(): Promise<string[]>;
+/**
+ * Save a command to the global history file
+ */
+export declare function saveCommandToHistory(command: string): Promise<void>;
+/**
+ * Display conversation preview with formatted messages
+ */
+export declare function displayConversationPreview(preview: ChatMessage[], maxPreview?: number): void;
+/**
+ * Parse a string value to its appropriate type (string, number, or boolean)
+ * Useful for parsing user input from CLI commands
+ */
+export declare function parseValue(value: string): string | number | boolean;
+/**
+ * Restore session variables from conversation metadata
+ * Extracts and sets session variables stored in conversation metadata
+ */
+export declare function restoreSessionVariables(conversationData: ConversationData): Promise<void>;
+export declare const HISTORY_FILE: string;
+export declare const LOOP_CACHE_CONFIG: {
+    readonly TTL_MS: number;
+};
+export declare const LOOP_DISPLAY_LIMITS: {
+    readonly MAX_CONVERSATIONS: 20;
+    readonly CONTENT_LENGTH: 50;
+    readonly TITLE_LENGTH: 40;
+    readonly SESSION_ID_DISPLAY: 12;
+    readonly SESSION_ID_SHORT: 8;
+    readonly PAGE_SIZE: 15;
+};