@juspay/neurolink 7.48.1 → 7.49.0

package/dist/lib/utils/loopUtils.js

@@ -0,0 +1,262 @@
+/**
+ * Loop Mode Utilities
+ * Utilities specific to CLI loop mode session management and restoration
+ */
+import chalk from "chalk";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { globalSession } from "../session/globalSessionState.js";
+import { logger } from "./logger.js";
+/**
+ * Verify that conversation context is accessible and properly loaded
+ * Uses the global session to access the NeuroLink instance
+ */
+export async function verifyConversationContext(sessionId) {
+    const session = globalSession.getLoopSession();
+    if (!session) {
+        logger.warn("No active session found for conversation verification");
+        return;
+    }
+    try {
+        const messages = await session.neurolinkInstance.getConversationHistory(sessionId);
+        logger.debug(`Successfully loaded ${messages.length} messages from conversation ${sessionId}`);
+        if (messages.length === 0) {
+            logger.warn(`No messages found for session ${sessionId} after restoration`);
+            logger.warn("The conversation exists in Redis but may not be accessible through the API");
+        }
+        else {
+            logger.info(`Conversation context restored successfully: ${messages.length} messages loaded`);
+        }
+    }
+    catch (error) {
+        logger.warn("Could not access conversation history after restoration:", error);
+        logger.warn("The conversation may still be accessible when generating new responses");
+    }
+}
+/**
+ * Get conversation context for display (first few and last few messages)
+ * Uses the global session to access the NeuroLink instance
+ */
+export async function getConversationPreview(sessionId, previewCount = 2) {
+    const session = globalSession.getLoopSession();
+    if (!session) {
+        logger.debug("No active session found for conversation preview");
+        return [];
+    }
+    try {
+        const allMessages = await session.neurolinkInstance.getConversationHistory(sessionId);
+        if (allMessages.length <= previewCount * 2) {
+            return allMessages;
+        }
+        const firstMessages = allMessages.slice(0, previewCount);
+        const lastMessages = allMessages.slice(-previewCount);
+        return [...firstMessages, ...lastMessages];
+    }
+    catch (error) {
+        logger.debug("Failed to get conversation preview:", error);
+        return [];
+    }
+}
+/**
+ * Generate a title from content by truncating to appropriate length
+ */
+export function generateConversationTitle(content) {
+    const truncated = content.slice(0, LOOP_DISPLAY_LIMITS.TITLE_LENGTH);
+    return truncated.length < content.length ? `${truncated}...` : truncated;
+}
+/**
+ * Truncate text content to specified length with ellipsis
+ */
+export function truncateText(content, maxLength) {
+    if (content.length <= maxLength) {
+        return content;
+    }
+    return `${content.slice(0, maxLength)}...`;
+}
+/**
+ * Format timestamp as human-readable relative time
+ * Uses Intl.RelativeTimeFormat for natural language output
+ */
+export function formatTimeAgo(timestamp) {
+    const now = Date.now();
+    const date = new Date(timestamp);
+    if (isNaN(date.getTime())) {
+        logger.warn(`Invalid timestamp provided: ${timestamp}`);
+        return "Unknown time";
+    }
+    const diffSeconds = Math.floor((date.getTime() - now) / 1000);
+    for (const { unit, seconds } of TIME_UNITS) {
+        if (Math.abs(diffSeconds) >= seconds || unit === "minute") {
+            return rtf.format(Math.round(diffSeconds / seconds), unit);
+        }
+    }
+    return rtf.format(0, "second");
+}
+/**
+ * Get appropriate icon for content based on regex patterns
+ */
+export function getContentIcon(content) {
+    const match = CONTENT_ICON_PATTERNS.find((pattern) => pattern.pattern.test(content));
+    return match?.icon ?? "📝";
+}
+/**
+ * Display session restoration status message
+ */
+export function displaySessionMessage(result) {
+    if (result.success) {
+        logger.always(chalk.green(`✅ Resumed conversation: ${result.sessionId.slice(0, LOOP_DISPLAY_LIMITS.SESSION_ID_DISPLAY)}...`));
+        logger.always(chalk.gray(`   ${result.messageCount} messages | Last activity: ${result.lastActivity
+            ? new Date(result.lastActivity).toLocaleString()
+            : "Unknown"}`));
+    }
+    else {
+        logger.always(chalk.red(`❌ Failed to restore conversation: ${result.error}`));
+        logger.always(chalk.gray("   Starting new conversation instead..."));
+    }
+}
+/**
+ * Load command history from the global history file
+ */
+export async function loadCommandHistory() {
+    try {
+        const content = await fs.readFile(HISTORY_FILE, "utf8");
+        return content.split("\n").filter((line) => line.trim());
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Save a command to the global history file
+ */
+export async function saveCommandToHistory(command) {
+    try {
+        const sensitivePattern = /\b(api[-_]?key|token|password|secret|authorization)\b/i;
+        if (sensitivePattern.test(command)) {
+            return;
+        }
+        await fs.writeFile(HISTORY_FILE, command + "\n", {
+            flag: "a",
+            mode: 0o600,
+        });
+        await fs.chmod(HISTORY_FILE, 0o600);
+    }
+    catch (error) {
+        logger.warn("Warning: Could not save command to history:", error);
+    }
+}
+/**
+ * Display conversation preview with formatted messages
+ */
+export function displayConversationPreview(preview, maxPreview = 2) {
+    if (preview.length === 0) {
+        return;
+    }
+    logger.always(chalk.gray("\n--- Conversation Preview ---"));
+    preview.slice(0, maxPreview).forEach((msg) => {
+        const role = msg.role === "user" ? chalk.cyan("You") : chalk.green("AI");
+        const content = msg.content.length > 100
+            ? msg.content.slice(0, 100) + "..."
+            : msg.content;
+        logger.always(`${role}: ${content}`);
+    });
+    if (preview.length > maxPreview) {
+        logger.always(chalk.gray("... (conversation continues)"));
+    }
+    logger.always(chalk.gray("--- End Preview ---\n"));
+}
+/**
+ * Parse a string value to its appropriate type (string, number, or boolean)
+ * Useful for parsing user input from CLI commands
+ */
+export function parseValue(value) {
+    // Try to parse as number
+    if (!isNaN(Number(value))) {
+        return Number(value);
+    }
+    // Try to parse as boolean
+    if (value.toLowerCase() === "true") {
+        return true;
+    }
+    if (value.toLowerCase() === "false") {
+        return false;
+    }
+    // Return as string
+    return value;
+}
+/**
+ * Restore session variables from conversation metadata
+ * Extracts and sets session variables stored in conversation metadata
+ */
+export async function restoreSessionVariables(conversationData) {
+    try {
+        // Check if conversation has stored session variables
+        const metadata = conversationData.metadata;
+        if (metadata && metadata.sessionVariables) {
+            logger.debug("Restoring session variables from conversation metadata");
+            const sessionVariables = metadata.sessionVariables;
+            for (const [key, value] of Object.entries(sessionVariables)) {
+                if (typeof value === "string" ||
+                    typeof value === "number" ||
+                    typeof value === "boolean") {
+                    globalSession.setSessionVariable(key, value);
+                    logger.debug(`Restored session variable: ${key} = ${value}`);
+                }
+            }
+        }
+        else {
+            logger.debug("No session variables found in conversation metadata");
+        }
+    }
+    catch (error) {
+        logger.warn("Failed to restore session variables:", error);
+        // Don't fail the restoration for this
+    }
+}
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+export const HISTORY_FILE = path.join(os.homedir(), ".neurolink_history");
+export const LOOP_CACHE_CONFIG = {
+    TTL_MS: 5 * 60 * 1000,
+};
+export const LOOP_DISPLAY_LIMITS = {
+    MAX_CONVERSATIONS: 20,
+    CONTENT_LENGTH: 50,
+    TITLE_LENGTH: 40,
+    SESSION_ID_DISPLAY: 12,
+    SESSION_ID_SHORT: 8,
+    PAGE_SIZE: 15,
+};
+const TIME_UNITS = [
+    { unit: "year", seconds: 31536000 },
+    { unit: "month", seconds: 2592000 },
+    { unit: "week", seconds: 604800 },
+    { unit: "day", seconds: 86400 },
+    { unit: "hour", seconds: 3600 },
+    { unit: "minute", seconds: 60 },
+];
+const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+const CONTENT_ICON_PATTERNS = [
+    {
+        icon: "💻",
+        pattern: /\b(code|debug|programming|function|class|bug|script|syntax|compile|error)\b/i,
+    },
+    {
+        icon: "💡",
+        pattern: /\b(explain|what|how|why|understand|clarify|learn|teach)\b/i,
+    },
+    {
+        icon: "📊",
+        pattern: /\b(analyz[e|ing]|data|report|metrics?|statistics?|chart|graph|visualiz[e|ation])\b/i,
+    },
+    {
+        icon: "✍️",
+        pattern: /\b(write|create|generat[e|ing]|compose|draft|build|author)\b/i,
+    },
+    {
+        icon: "🤖",
+        pattern: /\b(help|assist|support|guide|tutorial|show me)\b/i,
+    },
+];

package/dist/lib/utils/messageBuilder.d.ts

@@ -17,8 +17,9 @@ export declare function convertToCoreMessages(messages: MultimodalChatMessage[])
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
  * Supports both TextGenerationOptions and StreamOptions
+ * Enhanced with CSV file processing support
  */
-export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): CoreMessage[];
+export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): Promise<CoreMessage[]>;
 /**
  * Build multimodal message array with image support
  * Detects when images are present and routes through provider adapter

package/dist/lib/utils/messageBuilder.js

@@ -6,6 +6,7 @@
 import { CONVERSATION_INSTRUCTIONS } from "../config/conversationMemory.js";
 import { ProviderImageAdapter, MultimodalLogger, } from "../adapters/providerImageAdapter.js";
 import { logger } from "./logger.js";
+import { FileDetector } from "./fileDetector.js";
 import { request } from "undici";
 import { readFileSync, existsSync } from "fs";
 /**
@@ -164,12 +165,33 @@ function toCoreMessage(message) {
     }
     return null; // Filter out tool_call and tool_result messages
 }
+/**
+ * Format CSV metadata for LLM consumption
+ */
+function formatCSVMetadata(metadata) {
+    const parts = [];
+    if (metadata.rowCount !== undefined) {
+        parts.push(`${metadata.rowCount} data rows`);
+    }
+    if (metadata.columnCount !== undefined) {
+        parts.push(`${metadata.columnCount} columns`);
+    }
+    if (metadata.columnNames && metadata.columnNames.length > 0) {
+        const columns = metadata.columnNames.join(", ");
+        parts.push(`Columns: [${columns}]`);
+    }
+    if (metadata.hasEmptyColumns) {
+        parts.push(`⚠️ Contains empty column names`);
+    }
+    return parts.length > 0 ? `**Metadata**: ${parts.join(" | ")}` : "";
+}
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
  * Supports both TextGenerationOptions and StreamOptions
+ * Enhanced with CSV file processing support
  */
-export function buildMessagesArray(options) {
+export async function buildMessagesArray(options) {
     const messages = [];
     // Check if conversation history exists
     const hasConversationHistory = options.conversationMessages && options.conversationMessages.length > 0;
@@ -205,6 +227,76 @@ export function buildMessagesArray(options) {
     else if ("input" in options && options.input?.text) {
         currentPrompt = options.input.text;
     }
+    // Process CSV files if present and inject into prompt using proper CSV parser
+    if ("input" in options && options.input) {
+        const input = options.input;
+        let csvContent = "";
+        const csvOptions = "csvOptions" in options ? options.csvOptions : undefined;
+        // Process explicit csvFiles array
+        if (input.csvFiles && input.csvFiles.length > 0) {
+            for (let i = 0; i < input.csvFiles.length; i++) {
+                const csvFile = input.csvFiles[i];
+                const filename = extractFilename(csvFile, i);
+                const filePath = typeof csvFile === "string" ? csvFile : filename;
+                try {
+                    const result = await FileDetector.detectAndProcess(csvFile, {
+                        allowedTypes: ["csv"],
+                        csvOptions: csvOptions,
+                    });
+                    let csvSection = `\n\n## CSV Data from "${filename}":\n`;
+                    // Add metadata from csv-parser library
+                    if (result.metadata) {
+                        const metadataText = formatCSVMetadata(result.metadata);
+                        if (metadataText) {
+                            csvSection += metadataText + `\n\n`;
+                        }
+                    }
+                    csvSection += buildCSVToolInstructions(filePath);
+                    csvSection += result.content;
+                    csvContent += csvSection;
+                    logger.info(`[CSV] ✅ Processed: ${filename}`, result.metadata);
+                }
+                catch (error) {
+                    logger.error(`[CSV] ❌ Failed to process ${filename}:`, error);
+                    csvContent += `\n\n## CSV Data Error: Failed to process "${filename}"\nReason: ${error instanceof Error ? error.message : "Unknown error"}`;
+                }
+            }
+        }
+        // Process unified files array (auto-detect CSV)
+        if (input.files && input.files.length > 0) {
+            for (const file of input.files) {
+                const filename = extractFilename(file);
+                try {
+                    const result = await FileDetector.detectAndProcess(file, {
+                        maxSize: 10 * 1024 * 1024,
+                        allowedTypes: ["csv"],
+                        csvOptions: csvOptions,
+                    });
+                    if (result.type === "csv") {
+                        let csvSection = `\n\n## CSV Data from "${filename}":\n`;
+                        // Add metadata from csv-parser library
+                        if (result.metadata) {
+                            const metadataText = formatCSVMetadata(result.metadata);
+                            if (metadataText) {
+                                csvSection += metadataText + `\n\n`;
+                            }
+                        }
+                        csvSection += result.content;
+                        csvContent += csvSection;
+                        logger.info(`[FileDetector] ✅ CSV: ${filename}`, result.metadata);
+                    }
+                }
+                catch (error) {
+                    // Silently skip non-CSV files in auto-detect mode
+                    logger.debug(`[FileDetector] Skipped ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        // Prepend CSV content to current prompt
+        if (csvContent) {
+            currentPrompt = csvContent + (currentPrompt || "");
+        }
+    }
     if (currentPrompt?.trim()) {
         messages.push({
             role: "user",
@@ -218,13 +310,95 @@ export function buildMessagesArray(options) {
  * Detects when images are present and routes through provider adapter
  */
 export async function buildMultimodalMessagesArray(options, provider, model) {
+    // Process unified files array (auto-detect)
+    if (options.input.files && options.input.files.length > 0) {
+        logger.info(`[FileDetector] Processing ${options.input.files.length} file(s) with auto-detection`);
+        options.input.text = options.input.text || "";
+        for (const file of options.input.files) {
+            try {
+                const result = await FileDetector.detectAndProcess(file, {
+                    maxSize: 10 * 1024 * 1024,
+                    allowedTypes: ["csv", "image"],
+                    csvOptions: options.csvOptions,
+                });
+                if (result.type === "csv") {
+                    const filename = extractFilename(file);
+                    const filePath = typeof file === "string" ? file : filename;
+                    let csvSection = `\n\n## CSV Data from "${filename}":\n`;
+                    // Add metadata from csv-parser library
+                    if (result.metadata) {
+                        const metadataText = formatCSVMetadata(result.metadata);
+                        if (metadataText) {
+                            csvSection += metadataText + `\n\n`;
+                        }
+                    }
+                    csvSection += buildCSVToolInstructions(filePath);
+                    csvSection += result.content;
+                    options.input.text += csvSection;
+                    logger.info(`[FileDetector] ✅ CSV: ${filename}`);
+                }
+                else if (result.type === "image") {
+                    options.input.images = [
+                        ...(options.input.images || []),
+                        result.content,
+                    ];
+                    logger.info(`[FileDetector] ✅ Image: ${result.mimeType}`);
+                }
+            }
+            catch (error) {
+                logger.error(`[FileDetector] ❌ Failed to process file:`, error);
+            }
+        }
+    }
+    // Process explicit CSV files array
+    if (options.input.csvFiles && options.input.csvFiles.length > 0) {
+        logger.info(`[CSV] Processing ${options.input.csvFiles.length} explicit CSV file(s)`);
+        options.input.text = options.input.text || "";
+        for (let i = 0; i < options.input.csvFiles.length; i++) {
+            const csvFile = options.input.csvFiles[i];
+            try {
+                const result = await FileDetector.detectAndProcess(csvFile, {
+                    allowedTypes: ["csv"],
+                    csvOptions: options.csvOptions,
+                });
+                const filename = extractFilename(csvFile, i);
+                const filePath = typeof csvFile === "string" ? csvFile : filename;
+                let csvSection = `\n\n## CSV Data from "${filename}":\n`;
+                // Add metadata from csv-parser library
+                if (result.metadata) {
+                    const metadataText = formatCSVMetadata(result.metadata);
+                    if (metadataText) {
+                        csvSection += metadataText + `\n\n`;
+                    }
+                }
+                csvSection += buildCSVToolInstructions(filePath);
+                csvSection += result.content;
+                options.input.text += csvSection;
+                logger.info(`[CSV] ✅ Processed: ${filename}`);
+            }
+            catch (error) {
+                logger.error(`[CSV] ❌ Failed:`, error);
+                const filename = extractFilename(csvFile, i);
+                options.input.text += `\n\n## CSV Data Error: Failed to process "${filename}"`;
+                options.input.text += `\nReason: ${error instanceof Error ? error.message : "Unknown error"}`;
+            }
+        }
+    }
     // Check if this is a multimodal request
     const hasImages = (options.input.images && options.input.images.length > 0) ||
         (options.input.content &&
             options.input.content.some((c) => c.type === "image"));
     // If no images, use standard message building and convert to MultimodalChatMessage[]
     if (!hasImages) {
-        const standardMessages = buildMessagesArray(options);
+        // Clear csvFiles and files arrays to prevent duplication
+        // (already processed and added to options.input.text above)
+        if (options.input.csvFiles) {
+            options.input.csvFiles = [];
+        }
+        if (options.input.files) {
+            options.input.files = [];
+        }
+        const standardMessages = await buildMessagesArray(options);
         return standardMessages.map((msg) => ({
             role: msg.role,
             content: typeof msg.content === "string" ? msg.content : msg.content,
@@ -490,3 +664,24 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
     });
     return content;
 }
+/**
+ * Extract filename from file input
+ */
+function extractFilename(file, index = 0) {
+    if (typeof file === "string") {
+        if (file.startsWith("http")) {
+            try {
+                const url = new URL(file);
+                return url.pathname.split("/").pop() || `file-${index + 1}`;
+            }
+            catch {
+                return `file-${index + 1}`;
+            }
+        }
+        return (file.split("/").pop() || file.split("\\").pop() || `file-${index + 1}`);
+    }
+    return `file-${index + 1}`;
+}
+function buildCSVToolInstructions(filePath) {
+    return `\n**IMPORTANT**: For counting, aggregation, or statistical operations, use the analyzeCSV tool with filePath="${filePath}". The tool reads the file directly - do NOT pass CSV content.\n\nExample: analyzeCSV(filePath="${filePath}", operation="count_by_column", column="merchant_id")\n\n`;
+}

package/dist/lib/utils/optionsUtils.d.ts

@@ -5,7 +5,7 @@
  */
 import type { GenerateOptions, UnifiedGenerationOptions } from "../types/generateTypes.js";
 import type { StreamOptions } from "../types/streamTypes.js";
-import type { ExecutionContext } from "../mcp/contracts/mcpContract.js";
+import type { ExecutionContext } from "../types/tools.js";
 /**
  * Enhancement types for different optimization strategies
  */