@juspay/neurolink 7.48.0 → 7.49.0

package/dist/agent/directTools.d.ts

@@ -346,6 +346,61 @@ export declare const directAgentTools: {
             count?: undefined;
         }>;
     };
+    analyzeCSV: import("ai").Tool<z.ZodObject<{
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        operation: z.ZodEnum<["count_by_column", "sum_by_column", "average_by_column", "min_max_by_column", "describe"]>;
+        column: z.ZodOptional<z.ZodString>;
+        maxRows: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        filePath: string;
+        maxRows?: number | undefined;
+        column?: string | undefined;
+    }, {
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        filePath: string;
+        maxRows?: number | undefined;
+        column?: string | undefined;
+    }>, {
+        success: boolean;
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        column: string | undefined;
+        result: string;
+        rowCount: number;
+    } | {
+        success: boolean;
+        error: string;
+        operation?: undefined;
+        column?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+        column: string | undefined;
+    }> & {
+        execute: (args: {
+            operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+            filePath: string;
+            maxRows?: number | undefined;
+            column?: string | undefined;
+        }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+            column: string | undefined;
+            result: string;
+            rowCount: number;
+        } | {
+            success: boolean;
+            error: string;
+            operation?: undefined;
+            column?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
+            column: string | undefined;
+        }>;
+    };
     websearchGrounding: import("ai").Tool<z.ZodObject<{
         query: z.ZodString;
         maxResults: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;

package/dist/agent/directTools.js

@@ -8,6 +8,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { logger } from "../utils/logger.js";
 import { VertexAI } from "@google-cloud/vertexai";
+import { CSVProcessor } from "../utils/csvProcessor.js";
 // Runtime Google Search tool creation - bypasses TypeScript strict typing
 function createGoogleSearchTools() {
     const searchTool = {};
@@ -336,6 +337,271 @@ export const directAgentTools = {
             }
         },
     }),
+    analyzeCSV: tool({
+        description: "Analyze CSV file for accurate counting, aggregation, and statistical analysis. Use this for precise data operations like counting rows by column, calculating sums/averages, finding min/max values, etc. The tool reads the file directly - do NOT pass CSV content.",
+        parameters: z.object({
+            filePath: z
+                .string()
+                .refine((inputPath) => {
+                const resolvedPath = path.resolve(inputPath);
+                const normalizedPath = resolvedPath
+                    .toLowerCase()
+                    .replace(/\\/g, "/");
+                const sensitivePatterns = [
+                    "/etc/",
+                    "/sys/",
+                    "/proc/",
+                    "/dev/",
+                    "/root/",
+                    "/.ssh/",
+                    "/private/etc/",
+                    "/private/var/",
+                    "c:/windows/",
+                    "c:/program files/",
+                    "c:/programdata/",
+                ];
+                return !sensitivePatterns.some((pattern) => normalizedPath.startsWith(pattern));
+            }, {
+                message: "Invalid file path: access to system directories is not allowed",
+            })
+                .describe("Path to the CSV file to analyze (e.g., 'test/data.csv' or '/absolute/path/file.csv')"),
+            operation: z
+                .enum([
+                "count_by_column",
+                "sum_by_column",
+                "average_by_column",
+                "min_max_by_column",
+                "describe",
+            ])
+                .describe("Type of analysis to perform"),
+            column: z
+                .string()
+                .optional()
+                .describe("Column name for the operation (required for most operations)"),
+            maxRows: z
+                .number()
+                .optional()
+                .describe("Maximum rows to process (default: 1000)"),
+        }),
+        execute: async ({ filePath, operation, column, maxRows = 1000 }) => {
+            const startTime = Date.now();
+            logger.info(`[analyzeCSV] 🚀 START: file=${filePath}, operation=${operation}, column=${column}, maxRows=${maxRows}`);
+            try {
+                // Resolve file path
+                logger.debug(`[analyzeCSV] Resolving file: ${filePath}`);
+                const path = await import("path");
+                // Resolve path (support both relative and absolute)
+                const resolvedPath = path.isAbsolute(filePath)
+                    ? filePath
+                    : path.resolve(process.cwd(), filePath);
+                logger.debug(`[analyzeCSV] Resolved path: ${resolvedPath}`);
+                // Parse CSV using streaming from disk (memory efficient)
+                logger.info(`[analyzeCSV] Starting CSV parsing (max ${maxRows} rows)...`);
+                const rows = (await CSVProcessor.parseCSVFile(resolvedPath, maxRows));
+                logger.info(`[analyzeCSV] ✅ CSV parsing complete: ${rows.length} rows`);
+                if (rows.length === 0) {
+                    logger.warn(`[analyzeCSV] No data rows found`);
+                    return {
+                        success: false,
+                        error: "No data rows found in CSV",
+                    };
+                }
+                // Log column names
+                const columnNames = rows.length > 0 ? Object.keys(rows[0]) : [];
+                logger.info(`[analyzeCSV] Found ${rows.length} rows with columns:`, columnNames);
+                logger.info(`[analyzeCSV] Executing operation: ${operation}`);
+                let result;
+                switch (operation) {
+                    case "count_by_column": {
+                        logger.info(`[analyzeCSV] count_by_column: column=${column}`);
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for count_by_column operation",
+                            };
+                        }
+                        // Count occurrences of each value in the column
+                        const counts = {};
+                        logger.debug(`[analyzeCSV] Counting rows...`);
+                        for (const row of rows) {
+                            const value = row[column];
+                            if (value !== undefined) {
+                                counts[value] = (counts[value] || 0) + 1;
+                            }
+                        }
+                        logger.debug(`[analyzeCSV] Found ${Object.keys(counts).length} unique values`);
+                        // Sort by count descending
+                        logger.debug(`[analyzeCSV] Sorting results...`);
+                        result = Object.fromEntries(Object.entries(counts).sort(([, a], [, b]) => b - a));
+                        logger.info(`[analyzeCSV] ✅ count_by_column complete. Result:`, result);
+                        break;
+                    }
+                    case "sum_by_column": {
+                        logger.info(`[analyzeCSV] sum_by_column: column=${column}`);
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for sum_by_column operation",
+                            };
+                        }
+                        // Sum numeric values from the target column itself for each group
+                        const groups = {};
+                        logger.debug(`[analyzeCSV] Grouping and summing ${rows.length} rows...`);
+                        let processedRows = 0;
+                        let totalNumericValuesFound = 0;
+                        for (const row of rows) {
+                            const key = row[column];
+                            if (!key) {
+                                continue;
+                            }
+                            // Parse numeric value from the target column
+                            const value = row[column];
+                            if (value === undefined || value === null || value === "") {
+                                continue;
+                            }
+                            const num = parseFloat(value);
+                            if (isNaN(num)) {
+                                continue;
+                            }
+                            if (!groups[key]) {
+                                groups[key] = 0;
+                            }
+                            groups[key] += num;
+                            totalNumericValuesFound++;
+                            processedRows++;
+                            if (processedRows % 10 === 0) {
+                                logger.debug(`[analyzeCSV] Processed ${processedRows}/${rows.length} rows`);
+                            }
+                        }
+                        // Fail fast if no numeric data found in the requested column
+                        if (totalNumericValuesFound === 0) {
+                            return {
+                                success: false,
+                                error: `No numeric data found in column "${column}" for sum_by_column operation`,
+                            };
+                        }
+                        logger.debug(`[analyzeCSV] Calculated sums for ${Object.keys(groups).length} groups (${totalNumericValuesFound} numeric values)`);
+                        result = groups;
+                        logger.info(`[analyzeCSV] ✅ sum_by_column complete`);
+                        break;
+                    }
+                    case "average_by_column": {
+                        logger.info(`[analyzeCSV] average_by_column: column=${column}`);
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for average_by_column operation",
+                            };
+                        }
+                        // Average numeric values from the target column itself for each group
+                        const groups = {};
+                        logger.debug(`[analyzeCSV] Grouping and averaging ${rows.length} rows...`);
+                        let processedRows = 0;
+                        let totalNumericValuesFound = 0;
+                        for (const row of rows) {
+                            const key = row[column];
+                            if (!key) {
+                                continue;
+                            }
+                            // Parse numeric value from the target column
+                            const value = row[column];
+                            if (value === undefined || value === null || value === "") {
+                                continue;
+                            }
+                            const num = parseFloat(value);
+                            if (isNaN(num)) {
+                                continue;
+                            }
+                            if (!groups[key]) {
+                                groups[key] = { sum: 0, count: 0 };
+                            }
+                            groups[key].sum += num;
+                            groups[key].count++;
+                            totalNumericValuesFound++;
+                            processedRows++;
+                            if (processedRows % 10 === 0) {
+                                logger.debug(`[analyzeCSV] Processed ${processedRows}/${rows.length} rows`);
+                            }
+                        }
+                        // Fail fast if no numeric data found in the requested column
+                        if (totalNumericValuesFound === 0) {
+                            return {
+                                success: false,
+                                error: `No numeric data found in column "${column}" for average_by_column operation`,
+                            };
+                        }
+                        logger.debug(`[analyzeCSV] Calculated averages for ${Object.keys(groups).length} groups (${totalNumericValuesFound} numeric values)`);
+                        result = Object.fromEntries(Object.entries(groups).map(([k, v]) => [
+                            k,
+                            v.count > 0 ? v.sum / v.count : 0,
+                        ]));
+                        logger.info(`[analyzeCSV] ✅ average_by_column complete`);
+                        break;
+                    }
+                    case "min_max_by_column": {
+                        if (!column) {
+                            return {
+                                success: false,
+                                error: "Column name required for min_max_by_column operation",
+                            };
+                        }
+                        const values = rows
+                            .map((row) => row[column])
+                            .filter((v) => v !== undefined && v !== "");
+                        const numericValues = values
+                            .map((v) => parseFloat(v))
+                            .filter((n) => !isNaN(n));
+                        if (numericValues.length === 0) {
+                            return {
+                                success: false,
+                                error: `No numeric data found in column "${column}" for min_max_by_column operation`,
+                            };
+                        }
+                        result = {
+                            min: Math.min(...numericValues),
+                            max: Math.max(...numericValues),
+                            numericCount: numericValues.length,
+                            totalCount: values.length,
+                        };
+                        break;
+                    }
+                    case "describe": {
+                        const columnNames = rows.length > 0 ? Object.keys(rows[0]) : [];
+                        result = {
+                            total_rows: rows.length,
+                            columns: columnNames,
+                            column_count: columnNames.length,
+                        };
+                        break;
+                    }
+                    default:
+                        return {
+                            success: false,
+                            error: `Unknown operation: ${operation}`,
+                        };
+                }
+                const duration = Date.now() - startTime;
+                logger.info(`[analyzeCSV] 🏁 COMPLETE: ${operation} took ${duration}ms`);
+                const response = {
+                    success: true,
+                    operation,
+                    column,
+                    result: JSON.stringify(result, null, 2),
+                    rowCount: rows.length,
+                };
+                logger.debug(`[analyzeCSV] 📤 RETURNING TO LLM:`, JSON.stringify(response, null, 2));
+                return response;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    operation,
+                    column,
+                };
+            }
+        },
+    }),
     websearchGrounding: tool({
         description: "Search the web for current information using Google Search grounding. Returns raw search data for AI processing.",
         parameters: z.object({

package/dist/cli/factories/commandFactory.d.ts

@@ -6,6 +6,8 @@ export declare class CLICommandFactory {
     private static readonly commonOptions;
     private static buildOptions;
     private static processCliImages;
+    private static processCliCSVFiles;
+    private static processCliFiles;
     private static processOptions;
     private static handleOutput;
     private static isValidTokenUsage;

package/dist/cli/factories/commandFactory.js

@@ -49,6 +49,26 @@ export class CLICommandFactory {
             description: "Add image file for multimodal analysis (can be used multiple times)",
             alias: "i",
         },
+        csv: {
+            type: "string",
+            description: "Add CSV file for data analysis (can be used multiple times)",
+            alias: "c",
+        },
+        file: {
+            type: "string",
+            description: "Add file with auto-detection (CSV, image, etc. - can be used multiple times)",
+        },
+        csvMaxRows: {
+            type: "number",
+            default: 1000,
+            description: "Maximum number of CSV rows to process",
+        },
+        csvFormat: {
+            type: "string",
+            choices: ["raw", "markdown", "json"],
+            default: "raw",
+            description: "CSV output format (raw recommended for large files)",
+        },
         model: {
             type: "string",
             description: "Specific model to use (e.g. gemini-2.5-pro, gemini-2.5-flash)",
@@ -188,6 +208,20 @@ export class CLICommandFactory {
         // File paths will be converted to base64 by the message builder
         return imagePaths;
     }
+    // Helper method to process CLI CSV files
+    static processCliCSVFiles(csvFiles) {
+        if (!csvFiles) {
+            return undefined;
+        }
+        return Array.isArray(csvFiles) ? csvFiles : [csvFiles];
+    }
+    // Helper method to process CLI files with auto-detection
+    static processCliFiles(files) {
+        if (!files) {
+            return undefined;
+        }
+        return Array.isArray(files) ? files : [files];
+    }
     // Helper method to process common options
     static processOptions(argv) {
         // Handle noColor option by disabling chalk
@@ -674,7 +708,7 @@ export class CLICommandFactory {
     static createLoopCommand() {
         return {
             command: "loop",
-            describe: "Start an interactive loop session",
+            describe: "Start an interactive loop session with conversation management",
             builder: (yargs) => this.buildOptions(yargs, {
                 "enable-conversation-memory": {
                     type: "boolean",
@@ -696,9 +730,27 @@ export class CLICommandFactory {
                     description: "Automatically use Redis if available",
                     default: true,
                 },
+                resume: {
+                    type: "string",
+                    description: "Directly resume a specific conversation by session ID",
+                    alias: "r",
+                },
+                new: {
+                    type: "boolean",
+                    description: "Force start a new conversation (skip selection menu)",
+                    alias: "n",
+                },
+                "list-conversations": {
+                    type: "boolean",
+                    description: "List available conversations and exit",
+                    alias: "l",
+                },
             })
-                .example("$0 loop --no-auto-redis", "Start loop with memory storage only")
-                .example("$0 loop", "Start interactive session")
+                .example("$0 loop", "Start interactive session with conversation selection")
+                .example("$0 loop --new", "Force start new conversation")
+                .example("$0 loop --resume abc123", "Resume specific conversation")
+                .example("$0 loop --list-conversations", "List available conversations")
+                .example("$0 loop --no-auto-redis", "Use in-memory storage only")
                 .example("$0 loop --enable-conversation-memory", "Start loop with memory"),
             handler: async (argv) => {
                 if (globalSession.getCurrentSessionId()) {
@@ -706,7 +758,7 @@ export class CLICommandFactory {
                     return;
                 }
                 let conversationMemoryConfig;
-                const { enableConversationMemory, maxSessions, maxTurnsPerSession, autoRedis, } = argv;
+                const { enableConversationMemory, maxSessions, maxTurnsPerSession, autoRedis, listConversations, } = argv;
                 if (enableConversationMemory) {
                     let storageType = "memory";
                     if (autoRedis) {
@@ -731,7 +783,48 @@ export class CLICommandFactory {
                         maxTurnsPerSession: maxTurnsPerSession,
                     };
                 }
-                const session = new LoopSession(initializeCliParser, conversationMemoryConfig);
+                // Handle --list-conversations option
+                if (listConversations) {
+                    const { ConversationSelector } = await import("../loop/conversationSelector.js");
+                    const conversationSelector = new ConversationSelector();
+                    try {
+                        const hasConversations = await conversationSelector.hasStoredConversations();
+                        if (!hasConversations) {
+                            logger.always(chalk.yellow("📝 No stored conversations found"));
+                            return;
+                        }
+                        const conversations = await conversationSelector.getAvailableConversations();
+                        logger.always(chalk.blue("📋 Available Conversations:"));
+                        conversations.forEach((conv, index) => {
+                            const sessionId = conv.sessionId.slice(0, 12) + "...";
+                            const title = conv.title || "Untitled Conversation";
+                            const messageCount = conv.messageCount || 0;
+                            const lastActivity = conv.updatedAt
+                                ? new Date(conv.updatedAt).toLocaleDateString()
+                                : "Unknown";
+                            logger.always(`${index + 1}. ${chalk.cyan(sessionId)} - ${title}`);
+                            logger.always(`   ${chalk.gray(`${messageCount} messages | Last: ${lastActivity}`)}`);
+                        });
+                        logger.always(chalk.gray(`\nUse: neurolink loop --resume <session-id> to resume a conversation`));
+                    }
+                    catch (error) {
+                        logger.error("Failed to list conversations:", error);
+                    }
+                    finally {
+                        await conversationSelector.close();
+                    }
+                    return;
+                }
+                // Create enhanced session with direct session management options
+                const sessionOptions = {};
+                // Pass CLI options to session for direct session management
+                if (argv.resume && typeof argv.resume === "string") {
+                    sessionOptions.directResumeSessionId = argv.resume;
+                }
+                if (argv.new) {
+                    sessionOptions.forceNewSession = true;
+                }
+                const session = new LoopSession(initializeCliParser, conversationMemoryConfig, sessionOptions);
                 await session.start();
             },
         };
@@ -967,12 +1060,21 @@ export class CLICommandFactory {
                     toolsEnabled: !options.disableTools,
                 });
             }
-            // Process CLI images if provided
+            // Process CLI multimodal inputs
             const imageBuffers = CLICommandFactory.processCliImages(argv.image);
+            const csvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
+            const files = CLICommandFactory.processCliFiles(argv.file);
             const result = await sdk.generate({
-                input: imageBuffers
-                    ? { text: inputText, images: imageBuffers }
-                    : { text: inputText },
+                input: {
+                    text: inputText,
+                    ...(imageBuffers && { images: imageBuffers }),
+                    ...(csvFiles && { csvFiles }),
+                    ...(files && { files }),
+                },
+                csvOptions: {
+                    maxRows: argv.csvMaxRows,
+                    formatStyle: argv.csvFormat,
+                },
                 provider: enhancedOptions.provider,
                 model: enhancedOptions.model,
                 temperature: enhancedOptions.temperature,
@@ -1140,12 +1242,21 @@ export class CLICommandFactory {
         const context = sessionId
             ? { ...contextMetadata, sessionId }
             : contextMetadata;
-        // Process CLI images if provided
+        // Process CLI multimodal inputs
         const imageBuffers = CLICommandFactory.processCliImages(argv.image);
+        const csvFiles = CLICommandFactory.processCliCSVFiles(argv.csv);
+        const files = CLICommandFactory.processCliFiles(argv.file);
         const stream = await sdk.stream({
-            input: imageBuffers
-                ? { text: inputText, images: imageBuffers }
-                : { text: inputText },
+            input: {
+                text: inputText,
+                ...(imageBuffers && { images: imageBuffers }),
+                ...(csvFiles && { csvFiles }),
+                ...(files && { files }),
+            },
+            csvOptions: {
+                maxRows: argv.csvMaxRows,
+                formatStyle: argv.csvFormat,
+            },
             provider: enhancedOptions.provider,
             model: enhancedOptions.model,
             temperature: enhancedOptions.temperature,
@@ -1179,11 +1290,14 @@ export class CLICommandFactory {
         let fullContent = "";
         let contentReceived = false;
         const abortController = new AbortController();
-        // Create timeout promise for stream consumption (30 seconds)
+        // Create timeout promise for stream consumption (default: 30 seconds, respects user-provided timeout)
+        const streamTimeout = options.timeout && typeof options.timeout === "number"
+            ? options.timeout * 1000
+            : 30000;
         const timeoutPromise = new Promise((_, reject) => {
             const timeoutId = setTimeout(() => {
                 if (!contentReceived) {
-                    const timeoutError = new Error("\n❌ Stream timeout - no content received within 30 seconds\n" +
+                    const timeoutError = new Error(`\n❌ Stream timeout - no content received within ${streamTimeout / 1000} seconds\n` +
                         "This usually indicates authentication or network issues\n\n" +
                         "🔧 Try these steps:\n" +
                         "1. Check your provider credentials are configured correctly\n" +
@@ -1191,7 +1305,7 @@ export class CLICommandFactory {
                         `3. Use debug mode: neurolink stream "test" --provider ${options.provider} --debug`);
                     reject(timeoutError);
                 }
-            }, 30000);
+            }, streamTimeout);
             // Clean up timeout when aborted
             abortController.signal.addEventListener("abort", () => {
                 clearTimeout(timeoutId);

package/dist/cli/loop/conversationSelector.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Conversation Selector for Loop Mode
+ * Handles discovery and selection of stored conversations from Redis
+ */
+import type { ConversationSummary } from "../../lib/types/conversation.js";
+import type { RedisStorageConfig } from "../../lib/types/conversation.js";
+export declare class ConversationSelector {
+    private redisClient;
+    private redisConfig;
+    private conversationCache;
+    private cacheTimestamp;
+    constructor(redisConfig?: RedisStorageConfig);
+    /**
+     * Initialize Redis connection
+     */
+    private initializeRedis;
+    /**
+     * Get available conversations for a user
+     */
+    getAvailableConversations(userId?: string): Promise<ConversationSummary[]>;
+    /**
+     * Display conversation menu and get user selection
+     */
+    displayConversationMenu(userId?: string): Promise<string | "NEW_CONVERSATION">;
+    /**
+     * Check if there are any stored conversations
+     */
+    hasStoredConversations(userId?: string): Promise<boolean>;
+    /**
+     * Close Redis connection
+     */
+    close(): Promise<void>;
+    private scanConversationKeys;
+    private processConversationKeys;
+    private processSingleConversationKey;
+    private sortConversationsByDate;
+    private updateCache;
+    private filterConversationsByUser;
+    private createMenuChoices;
+    private showSelectionPrompt;
+    private handleRetrievalError;
+    private handleMenuError;
+    private createConversationSummary;
+    private formatConversationChoice;
+}