@juspay/neurolink 7.48.0 → 7.49.0

package/dist/cli/loop/conversationSelector.js

@@ -0,0 +1,222 @@
+/**
+ * Conversation Selector for Loop Mode
+ * Handles discovery and selection of stored conversations from Redis
+ */
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { createRedisClient, scanKeys, deserializeConversation, getNormalizedConfig, } from "../../lib/utils/redis.js";
+import { logger } from "../../lib/utils/logger.js";
+import { LOOP_CACHE_CONFIG, LOOP_DISPLAY_LIMITS, generateConversationTitle, truncateText, formatTimeAgo, getContentIcon, } from "../../lib/utils/loopUtils.js";
+export class ConversationSelector {
+    redisClient = null;
+    redisConfig;
+    conversationCache = null;
+    cacheTimestamp = 0;
+    constructor(redisConfig = {}) {
+        this.redisConfig = getNormalizedConfig(redisConfig);
+    }
+    /**
+     * Initialize Redis connection
+     */
+    async initializeRedis() {
+        if (!this.redisClient) {
+            this.redisClient = await createRedisClient(this.redisConfig);
+        }
+    }
+    /**
+     * Get available conversations for a user
+     */
+    async getAvailableConversations(userId) {
+        // Check if cached conversations are still valid (within TTL)
+        if (this.conversationCache &&
+            Date.now() - this.cacheTimestamp < LOOP_CACHE_CONFIG.TTL_MS) {
+            logger.debug("Using cached conversation list");
+            return this.filterConversationsByUser(this.conversationCache, userId);
+        }
+        try {
+            await this.initializeRedis();
+            if (!this.redisClient) {
+                throw new Error("Redis client not available");
+            }
+            const keys = await this.scanConversationKeys();
+            if (keys.length === 0) {
+                logger.debug("No conversations found in Redis");
+                return [];
+            }
+            const summaries = await this.processConversationKeys(keys);
+            const sortedSummaries = this.sortConversationsByDate(summaries);
+            this.updateCache(sortedSummaries);
+            return this.filterConversationsByUser(sortedSummaries, userId);
+        }
+        catch (error) {
+            return this.handleRetrievalError(error);
+        }
+    }
+    /**
+     * Display conversation menu and get user selection
+     */
+    async displayConversationMenu(userId) {
+        try {
+            const conversations = await this.getAvailableConversations(userId);
+            if (conversations.length === 0) {
+                logger.debug("No conversations available for selection");
+                return "NEW_CONVERSATION";
+            }
+            const choices = this.createMenuChoices(conversations);
+            return await this.showSelectionPrompt(choices);
+        }
+        catch (error) {
+            return this.handleMenuError(error);
+        }
+    }
+    /**
+     * Check if there are any stored conversations
+     */
+    async hasStoredConversations(userId) {
+        try {
+            const conversations = await this.getAvailableConversations(userId);
+            return conversations.length > 0;
+        }
+        catch (error) {
+            logger.debug("Failed to check for stored conversations:", error);
+            return false;
+        }
+    }
+    /**
+     * Close Redis connection
+     */
+    async close() {
+        if (this.redisClient) {
+            await this.redisClient.quit();
+            this.redisClient = null;
+        }
+    }
+    async scanConversationKeys() {
+        if (!this.redisClient) {
+            throw new Error("Redis client not initialized");
+        }
+        const pattern = `${this.redisConfig.keyPrefix}*`;
+        const keys = await scanKeys(this.redisClient, pattern);
+        logger.debug(`Found ${keys.length} conversation keys in Redis`);
+        return keys;
+    }
+    async processConversationKeys(keys) {
+        const summaries = [];
+        for (const key of keys) {
+            const summary = await this.processSingleConversationKey(key);
+            if (summary) {
+                summaries.push(summary);
+            }
+        }
+        return summaries;
+    }
+    async processSingleConversationKey(key) {
+        if (!this.redisClient) {
+            logger.warn(`Redis client not available for key ${key}`);
+            return null;
+        }
+        try {
+            const conversationData = await this.redisClient.get(key);
+            const conversation = deserializeConversation(conversationData);
+            if (conversation &&
+                conversation.messages &&
+                conversation.messages.length > 0) {
+                return this.createConversationSummary(conversation);
+            }
+            return null;
+        }
+        catch (error) {
+            logger.warn(`Failed to process conversation key ${key}:`, error);
+            return null;
+        }
+    }
+    sortConversationsByDate(summaries) {
+        return summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    updateCache(summaries) {
+        this.conversationCache = summaries;
+        this.cacheTimestamp = Date.now();
+        logger.debug(`Retrieved ${summaries.length} valid conversations`);
+    }
+    filterConversationsByUser(summaries, userId) {
+        if (!userId) {
+            return summaries;
+        }
+        return summaries.filter((summary) => summary.userId === userId);
+    }
+    /*
+     * Create menu choices for inquirer prompt
+     */
+    createMenuChoices(conversations) {
+        const choices = [
+            {
+                name: chalk.green("🆕 Start New Conversation"),
+                value: "NEW_CONVERSATION",
+                short: "New Conversation",
+            },
+            new inquirer.Separator(),
+        ];
+        for (const conversation of conversations.slice(0, LOOP_DISPLAY_LIMITS.MAX_CONVERSATIONS)) {
+            const choice = this.formatConversationChoice(conversation);
+            choices.push(choice);
+        }
+        return choices;
+    }
+    async showSelectionPrompt(choices) {
+        const answer = await inquirer.prompt([
+            {
+                type: "list",
+                name: "selectedConversation",
+                message: "Select a conversation to continue:",
+                choices,
+                pageSize: LOOP_DISPLAY_LIMITS.PAGE_SIZE,
+            },
+        ]);
+        return answer.selectedConversation;
+    }
+    handleRetrievalError(error) {
+        logger.error("Failed to retrieve conversations:", error);
+        return [];
+    }
+    handleMenuError(error) {
+        logger.error("Failed to display conversation menu:", error);
+        return "NEW_CONVERSATION";
+    }
+    createConversationSummary(conversation) {
+        const messages = conversation.messages;
+        const firstMessage = messages[0];
+        const lastMessage = messages[messages.length - 1];
+        return {
+            sessionId: conversation.sessionId,
+            id: conversation.id,
+            title: conversation.title || generateConversationTitle(firstMessage.content),
+            firstMessage: {
+                content: truncateText(firstMessage.content, LOOP_DISPLAY_LIMITS.CONTENT_LENGTH),
+                timestamp: firstMessage.timestamp || conversation.createdAt,
+            },
+            lastMessage: {
+                content: truncateText(lastMessage.content, LOOP_DISPLAY_LIMITS.CONTENT_LENGTH),
+                timestamp: lastMessage.timestamp || conversation.updatedAt,
+            },
+            messageCount: messages.length,
+            userId: conversation.userId,
+            duration: formatTimeAgo(conversation.updatedAt),
+            createdAt: conversation.createdAt,
+            updatedAt: conversation.updatedAt,
+        };
+    }
+    formatConversationChoice(summary) {
+        const icon = getContentIcon(summary.firstMessage.content);
+        const title = chalk.white(summary.title || "Untitled Conversation");
+        const duration = chalk.gray(`(${summary.duration})`);
+        const details = chalk.gray(`     └ ${summary.messageCount} message${summary.messageCount !== 1 ? "s" : ""} | ` +
+            `Session: ${summary.sessionId.slice(0, LOOP_DISPLAY_LIMITS.SESSION_ID_DISPLAY)}... | ` +
+            `Updated: ${new Date(summary.updatedAt).toLocaleString()}`);
+        const name = `${icon} ${title} ${duration}\n${details}`;
+        return {
+            name,
+            value: summary.sessionId,
+            short: `${summary.title} (${summary.sessionId.slice(0, LOOP_DISPLAY_LIMITS.SESSION_ID_SHORT)}...)`,
+        };
+    }
+}

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

@@ -12,4 +12,4 @@ export interface OptionSchema {
  * This object provides metadata for validation and help text in the CLI loop.
  * It is derived from the main TextGenerationOptions interface to ensure consistency.
  */
-export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region">, OptionSchema>;
+export declare const textGenerationOptionsSchema: Record<keyof Omit<TextGenerationOptions, "prompt" | "input" | "schema" | "tools" | "context" | "conversationHistory" | "conversationMessages" | "conversationMemoryConfig" | "originalPrompt" | "middleware" | "expectedOutcome" | "evaluationCriteria" | "region" | "csvOptions">, OptionSchema>;

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

@@ -2,27 +2,55 @@ import type { Argv } from "yargs";
 import type { ConversationMemoryConfig } from "../../lib/types/conversation.js";
 export declare class LoopSession {
     private conversationMemoryConfig?;
+    private options?;
     private initializeCliParser;
     private isRunning;
     private sessionId?;
     private commandHistory;
     private sessionVariablesSchema;
-    constructor(initializeCliParser: () => Argv, conversationMemoryConfig?: ConversationMemoryConfig | undefined);
+    constructor(initializeCliParser: () => Argv, conversationMemoryConfig?: ConversationMemoryConfig | undefined, options?: {
+        directResumeSessionId?: string;
+        forceNewSession?: boolean;
+    } | undefined);
     start(): Promise<void>;
+    /**
+     * Handle direct session resume from CLI option
+     */
+    private handleDirectSessionResume;
+    /**
+     * Handle conversation selection logic when no direct resume is specified
+     */
+    private handleConversationSelection;
+    /**
+     * Clean up session resources and connections
+     */
+    private cleanup;
     private handleSessionCommands;
-    private parseValue;
     private showHelp;
     private showSetHelp;
     /**
-     * Load command history from the global history file
+     * Get command input with history support using readline
+     */
+    private getCommandWithHistory;
+    /**
+     * Restore a conversation session and set up the global session state
      */
-    private loadHistory;
+    private restoreSession;
     /**
-     * Save a command to the global history file
+     * Create NeuroLink instance and validate conversation in one step
+     * Eliminates redundant instance creation and initialization
      */
-    private saveCommand;
+    private createAndValidateNeurolinkInstance;
     /**
-     * Get command input with history support using readline
+     * Configure tool execution context for the restored session
      */
-    private getCommandWithHistory;
+    private configureToolContext;
+    /**
+     * Verify that tools are available and working in the restored session
+     */
+    private verifyToolAvailability;
+    /**
+     * Restore global session state and session variables
+     */
+    private restoreGlobalSessionState;
 }