@juspay/neurolink 9.87.4 → 9.88.0

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

@@ -261,6 +261,45 @@ export declare class CLICommandFactory {
      * Execute memory clear command
      */
     private static executeMemoryClear;
+    /**
+     * Execute memory list command
+     */
+    private static executeMemoryList;
+    /**
+     * Resolve the requested export format for memory export commands.
+     * The generic `--format` flag is typed for the generate/stream commands
+     * (text/json/table/yaml), so read the raw value here and narrow it to the
+     * two serializations the memory export path actually supports.
+     */
+    private static resolveMemoryExportFormat;
+    /**
+     * Build a filesystem-safe filename for a session export.
+     *
+     * A session ID is caller-controlled data (it can come from Redis keys, user
+     * input, etc.), so it must never be interpolated directly into a path — a
+     * value like `../../etc/cron.d/x` would otherwise let export-all write
+     * outside the chosen output directory. We reduce the ID to a bare basename
+     * and allow-list its characters; callers additionally verify containment.
+     */
+    private static sanitizeSessionExportFilename;
+    /**
+     * Serialize one or more session exports to CSV. Each message becomes a row;
+     * session-level fields are repeated per row so the output is a flat,
+     * spreadsheet-friendly table.
+     */
+    private static sessionExportsToCsv;
+    /**
+     * Execute memory export command
+     */
+    private static executeMemoryExport;
+    /**
+     * Execute memory export-all command
+     */
+    private static executeMemoryExportAll;
+    /**
+     * Execute memory delete command
+     */
+    private static executeMemoryDelete;
     /**
      * Execute completion command
      */

package/dist/cli/factories/commandFactory.js

@@ -1636,9 +1636,85 @@ export class CLICommandFactory {
     static createMemoryCommands() {
         return {
             command: "memory <subcommand>",
-            describe: "Manage conversation memory",
+            describe: "Manage conversation memory and session history",
             builder: (yargs) => {
                 return yargs
+                    .command("list", "List all conversation sessions with metadata", (y) => CLICommandFactory.buildOptions(y)
+                    .option("user-id", {
+                    type: "string",
+                    description: "User ID to filter sessions (required for Redis)",
+                    alias: "u",
+                })
+                    .example("$0 memory list", "List all sessions")
+                    .example("$0 memory list --format json", "List sessions as JSON")
+                    .example("$0 memory list --user-id user123", "List sessions for specific user"), async (argv) => await CLICommandFactory.executeMemoryList(argv))
+                    .command("export", "Export a specific session to JSON/CSV", (y) => CLICommandFactory.buildOptions(y)
+                    .option("session-id", {
+                    type: "string",
+                    description: "Session ID to export",
+                    demandOption: true,
+                    alias: "s",
+                })
+                    .option("include-metadata", {
+                    type: "boolean",
+                    default: false,
+                    description: "Include export metadata",
+                })
+                    // Override the generic --format so this command accepts csv.
+                    // (Alias -f / --output-format comes from the common options.)
+                    .option("format", {
+                    choices: ["json", "csv"],
+                    default: "json",
+                    description: "Export format (json or csv)",
+                })
+                    .example("$0 memory export --session-id session-123", "Export session to stdout")
+                    .example("$0 memory export --session-id session-123 --format json > history.json", "Export to file")
+                    .example("$0 memory export --session-id session-123 --format csv > history.csv", "Export as CSV")
+                    .example("$0 memory export --session-id session-123 --include-metadata", "Export with metadata"), async (argv) => await CLICommandFactory.executeMemoryExport(argv))
+                    .command("export-all", "Export all sessions to a directory", (y) => CLICommandFactory.buildOptions(y)
+                    .option("output", {
+                    type: "string",
+                    description: "Output directory for exported files",
+                    default: "./memory-exports",
+                    alias: "o",
+                })
+                    .option("user-id", {
+                    type: "string",
+                    description: "User ID to filter sessions (required for Redis)",
+                    alias: "u",
+                })
+                    .option("include-metadata", {
+                    type: "boolean",
+                    default: true,
+                    description: "Include export metadata",
+                })
+                    // Override the generic --format so this command accepts csv;
+                    // it controls the extension/serialization of the per-session
+                    // files written to the output directory. (Alias -f /
+                    // --output-format comes from the common options.)
+                    .option("format", {
+                    choices: ["json", "csv"],
+                    default: "json",
+                    description: "Per-file export format (json or csv)",
+                })
+                    .example("$0 memory export-all --output ./exports/", "Export all sessions to directory")
+                    .example("$0 memory export-all --user-id user123 --output ./user-exports/", "Export all sessions for user")
+                    .example("$0 memory export-all --output ./exports/ --format csv", "Export all sessions as CSV files"), async (argv) => await CLICommandFactory.executeMemoryExportAll(argv))
+                    .command("delete", "Delete a specific conversation session", (y) => CLICommandFactory.buildOptions(y)
+                    .option("session-id", {
+                    type: "string",
+                    description: "Session ID to delete",
+                    demandOption: true,
+                    alias: "s",
+                })
+                    .option("force", {
+                    type: "boolean",
+                    default: false,
+                    description: "Skip confirmation prompt",
+                    alias: "f",
+                })
+                    .example("$0 memory delete --session-id session-123", "Delete session with confirmation")
+                    .example("$0 memory delete --session-id session-123 --force", "Delete session without confirmation"), async (argv) => await CLICommandFactory.executeMemoryDelete(argv))
                     .command("stats", "Show conversation memory statistics", (y) => CLICommandFactory.buildOptions(y)
                     .example("$0 memory stats", "Show memory usage statistics")
                     .example("$0 memory stats --format json", "Export stats as JSON"), async (argv) => await CLICommandFactory.executeMemoryStats(argv))
@@ -1650,13 +1726,18 @@ export class CLICommandFactory {
                 })
                     .example("$0 memory history session-123", "Show conversation history")
                     .example("$0 memory history session-123 --format json", "Export history as JSON"), async (argv) => await CLICommandFactory.executeMemoryHistory(argv))
-                    .command("clear [sessionId]", "Clear conversation history", (y) => CLICommandFactory.buildOptions(y)
+                    .command("clear [sessionId]", "Clear conversation history (use --confirm to clear all)", (y) => CLICommandFactory.buildOptions(y)
                     .positional("sessionId", {
                     type: "string",
                     description: "Session ID to clear (omit to clear all sessions)",
                     demandOption: false,
                 })
-                    .example("$0 memory clear", "Clear all conversation history")
+                    .option("confirm", {
+                    type: "boolean",
+                    default: false,
+                    description: "Confirm clearing all sessions",
+                })
+                    .example("$0 memory clear --confirm", "Clear all conversation history")
                     .example("$0 memory clear session-123", "Clear specific session"), async (argv) => await CLICommandFactory.executeMemoryClear(argv))
                     .demandCommand(1, "Please specify a memory subcommand");
             },
@@ -3709,6 +3790,13 @@ export class CLICommandFactory {
     static async executeMemoryClear(argv) {
         const options = CLICommandFactory.processOptions(argv);
         const isAllSessions = !argv.sessionId;
+        // Require --confirm flag when clearing all sessions
+        if (isAllSessions && !argv.confirm) {
+            logger.always(chalk.red("⚠️ Clearing all sessions requires --confirm flag"));
+            logger.always(chalk.yellow("Usage: neurolink memory clear --confirm"));
+            logger.always(chalk.gray("This safeguard prevents accidental data loss."));
+            return;
+        }
         const target = isAllSessions ? "all sessions" : `session ${argv.sessionId}`;
         const spinner = options.quiet
             ? null
@@ -3777,6 +3865,399 @@ export class CLICommandFactory {
             }
         }
     }
+    /**
+     * Execute memory list command
+     */
+    static async executeMemoryList(argv) {
+        const options = CLICommandFactory.processOptions(argv);
+        const spinner = options.quiet
+            ? null
+            : ora("📋 Listing conversation sessions...").start();
+        try {
+            const sdk = globalSession.getOrCreateNeuroLink();
+            // Handle dry-run mode
+            if (options.dryRun) {
+                const mockSessions = [
+                    {
+                        id: "session-123",
+                        title: "Machine Learning Discussion",
+                        messageCount: 15,
+                        lastActive: "2 hours ago",
+                        createdAt: "2024-01-01T10:00:00Z",
+                        updatedAt: "2024-01-01T12:30:00Z",
+                    },
+                    {
+                        id: "session-456",
+                        title: "API Design Review",
+                        messageCount: 8,
+                        lastActive: "1 day ago",
+                        createdAt: "2024-01-02T14:00:00Z",
+                        updatedAt: "2024-01-02T15:15:00Z",
+                    },
+                ];
+                if (spinner) {
+                    spinner.succeed(chalk.green("✅ Sessions listed (dry-run)"));
+                }
+                CLICommandFactory.handleOutput(mockSessions, options);
+                return;
+            }
+            const sessions = await sdk.listSessions(argv.userId);
+            if (spinner) {
+                spinner.succeed(chalk.green(`✅ Found ${sessions.length} session(s)`));
+            }
+            if (sessions.length === 0) {
+                logger.always(chalk.yellow("⚠️ No conversation sessions found"));
+                return;
+            }
+            if (options.format === "json") {
+                CLICommandFactory.handleOutput(sessions, options);
+            }
+            else {
+                // Table format output
+                logger.always(chalk.blue(`📋 Conversation Sessions (${sessions.length} total):`));
+                logger.always("");
+                logger.always(chalk.gray("Session ID".padEnd(40) +
+                    " | " +
+                    "Messages".padEnd(10) +
+                    " | " +
+                    "Last Active"));
+                logger.always(chalk.gray("-".repeat(75)));
+                for (const session of sessions) {
+                    const idDisplay = session.id.length > 38
+                        ? session.id.substring(0, 35) + "..."
+                        : session.id.padEnd(40);
+                    const msgCount = String(session.messageCount).padEnd(10);
+                    const lastActive = session.lastActive || "Unknown";
+                    logger.always(`${idDisplay} | ${msgCount} | ${lastActive}`);
+                }
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Session listing failed");
+            }
+            if (error.message.includes("not enabled")) {
+                logger.always(chalk.yellow("⚠️ Conversation memory is not enabled"));
+                logger.always("Enable it by using --enable-conversation-memory with loop mode");
+            }
+            else {
+                handleError(error, "Memory list");
+            }
+        }
+    }
+    /**
+     * Resolve the requested export format for memory export commands.
+     * The generic `--format` flag is typed for the generate/stream commands
+     * (text/json/table/yaml), so read the raw value here and narrow it to the
+     * two serializations the memory export path actually supports.
+     */
+    static resolveMemoryExportFormat(argv) {
+        const raw = typeof argv.format === "string" ? argv.format.toLowerCase() : "";
+        return raw === "csv" ? "csv" : "json";
+    }
+    /**
+     * Build a filesystem-safe filename for a session export.
+     *
+     * A session ID is caller-controlled data (it can come from Redis keys, user
+     * input, etc.), so it must never be interpolated directly into a path — a
+     * value like `../../etc/cron.d/x` would otherwise let export-all write
+     * outside the chosen output directory. We reduce the ID to a bare basename
+     * and allow-list its characters; callers additionally verify containment.
+     */
+    static sanitizeSessionExportFilename(sessionId, extension) {
+        // Strip any directory components, then drop everything that isn't a safe
+        // filename character and any leading dots (which could form `..`).
+        const base = path.basename(String(sessionId ?? ""));
+        const sanitized = base.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^\.+/, "");
+        const safe = sanitized.length > 0 ? sanitized : "session";
+        return `${safe}.${extension}`;
+    }
+    /**
+     * Serialize one or more session exports to CSV. Each message becomes a row;
+     * session-level fields are repeated per row so the output is a flat,
+     * spreadsheet-friendly table.
+     */
+    static sessionExportsToCsv(exports) {
+        const escape = (value) => {
+            const s = value === undefined || value === null ? "" : String(value);
+            return /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+        };
+        const header = [
+            "sessionId",
+            "title",
+            "messageId",
+            "role",
+            "content",
+            "timestamp",
+            "tool",
+        ];
+        const rows = [header.join(",")];
+        for (const exp of exports) {
+            for (const msg of exp.messages) {
+                rows.push([
+                    escape(exp.sessionId),
+                    escape(exp.title),
+                    escape(msg.id),
+                    escape(msg.role),
+                    escape(msg.content),
+                    escape(msg.timestamp ?? msg.metadata?.timestamp),
+                    escape(msg.tool),
+                ].join(","));
+            }
+        }
+        return rows.join("\r\n") + "\r\n";
+    }
+    /**
+     * Execute memory export command
+     */
+    static async executeMemoryExport(argv) {
+        const options = CLICommandFactory.processOptions(argv);
+        const exportFormat = CLICommandFactory.resolveMemoryExportFormat(argv);
+        const spinner = options.quiet
+            ? null
+            : ora(`📤 Exporting session ${argv.sessionId}...`).start();
+        try {
+            const sdk = globalSession.getOrCreateNeuroLink();
+            // Handle dry-run mode
+            if (options.dryRun) {
+                const mockExport = {
+                    sessionId: argv.sessionId,
+                    title: "Sample Conversation",
+                    createdAt: "2024-01-01T10:00:00Z",
+                    updatedAt: "2024-01-01T12:30:00Z",
+                    messages: [
+                        { id: "msg-1", role: "user", content: "Hello!" },
+                        { id: "msg-2", role: "assistant", content: "Hi there!" },
+                    ],
+                    exportMetadata: argv.includeMetadata
+                        ? {
+                            exportedAt: new Date().toISOString(),
+                            exportFormat,
+                        }
+                        : undefined,
+                };
+                if (spinner) {
+                    spinner.succeed(chalk.green(`✅ Session exported (dry-run)`));
+                }
+                if (exportFormat === "csv") {
+                    logger.always(CLICommandFactory.sessionExportsToCsv([mockExport]));
+                }
+                else {
+                    CLICommandFactory.handleOutput(mockExport, {
+                        ...options,
+                        format: "json",
+                    });
+                }
+                return;
+            }
+            const exportData = await sdk.exportSession(argv.sessionId, {
+                includeMetadata: argv.includeMetadata,
+                format: exportFormat,
+            });
+            if (!exportData) {
+                if (spinner) {
+                    spinner.warn(chalk.yellow(`⚠️ Session ${argv.sessionId} not found`));
+                }
+                return;
+            }
+            if (spinner) {
+                spinner.succeed(chalk.green(`✅ Session exported (${exportData.messages.length} messages)`));
+            }
+            // Emit in the requested format (suitable for piping to a file).
+            if (exportFormat === "csv") {
+                logger.always(CLICommandFactory.sessionExportsToCsv([exportData]));
+            }
+            else {
+                CLICommandFactory.handleOutput(exportData, {
+                    ...options,
+                    format: "json",
+                });
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Session export failed");
+            }
+            if (error.message.includes("not enabled")) {
+                logger.always(chalk.yellow("⚠️ Conversation memory is not enabled"));
+                logger.always("Enable it by using --enable-conversation-memory with loop mode");
+            }
+            else {
+                handleError(error, "Memory export");
+            }
+        }
+    }
+    /**
+     * Execute memory export-all command
+     */
+    static async executeMemoryExportAll(argv) {
+        const options = CLICommandFactory.processOptions(argv);
+        const exportFormat = CLICommandFactory.resolveMemoryExportFormat(argv);
+        const spinner = options.quiet
+            ? null
+            : ora("📤 Exporting all sessions...").start();
+        try {
+            const sdk = globalSession.getOrCreateNeuroLink();
+            // Handle dry-run mode
+            if (options.dryRun) {
+                if (spinner) {
+                    spinner.succeed(chalk.green(`✅ Sessions would be exported to ${argv.output} (dry-run)`));
+                }
+                const result = {
+                    success: true,
+                    outputDirectory: argv.output,
+                    sessionCount: 2,
+                    message: "Dry-run: sessions would be exported",
+                };
+                CLICommandFactory.handleOutput(result, options);
+                return;
+            }
+            // Ensure output directory exists
+            if (!fs.existsSync(argv.output)) {
+                fs.mkdirSync(argv.output, { recursive: true });
+            }
+            const exports = await sdk.exportAllSessions(argv.userId, {
+                includeMetadata: argv.includeMetadata,
+                format: exportFormat,
+            });
+            if (exports.length === 0) {
+                if (spinner) {
+                    spinner.warn(chalk.yellow("⚠️ No sessions found to export"));
+                }
+                return;
+            }
+            // Write each session to a file. The session ID is untrusted input, so it
+            // is sanitized to a bare filename and the resolved path is verified to
+            // stay inside the output directory before writing (path-traversal guard).
+            const resolvedOutput = path.resolve(argv.output);
+            let writtenCount = 0;
+            for (const sessionExport of exports) {
+                const filename = CLICommandFactory.sanitizeSessionExportFilename(sessionExport.sessionId, exportFormat);
+                const filepath = path.resolve(resolvedOutput, filename);
+                // Defense-in-depth: refuse to write anything that escaped the dir.
+                if (path.dirname(filepath) !== resolvedOutput) {
+                    logger.always(chalk.yellow(`⚠️ Skipping session with unsafe id: ${sessionExport.sessionId}`));
+                    continue;
+                }
+                const contents = exportFormat === "csv"
+                    ? CLICommandFactory.sessionExportsToCsv([sessionExport])
+                    : JSON.stringify(sessionExport, null, 2);
+                fs.writeFileSync(filepath, contents);
+                writtenCount++;
+            }
+            if (spinner) {
+                spinner.succeed(chalk.green(`✅ Exported ${writtenCount} session(s) to ${argv.output}`));
+            }
+            if (options.format === "json") {
+                const result = {
+                    success: true,
+                    outputDirectory: argv.output,
+                    format: exportFormat,
+                    sessionCount: writtenCount,
+                    sessions: exports.map((e) => ({
+                        sessionId: e.sessionId,
+                        messageCount: e.messages.length,
+                    })),
+                };
+                CLICommandFactory.handleOutput(result, options);
+            }
+            else {
+                logger.always(chalk.blue(`📁 Exported sessions to: ${argv.output}`));
+                for (const sessionExport of exports) {
+                    logger.always(`   • ${sessionExport.sessionId} (${sessionExport.messages.length} messages)`);
+                }
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Export all failed");
+            }
+            if (error.message.includes("not enabled")) {
+                logger.always(chalk.yellow("⚠️ Conversation memory is not enabled"));
+                logger.always("Enable it by using --enable-conversation-memory with loop mode");
+            }
+            else {
+                handleError(error, "Memory export-all");
+            }
+        }
+    }
+    /**
+     * Execute memory delete command
+     */
+    static async executeMemoryDelete(argv) {
+        const options = CLICommandFactory.processOptions(argv);
+        // Require confirmation unless --force is explicitly provided
+        if (!argv.force) {
+            // In quiet mode, we can't prompt interactively, so require --force
+            if (options.quiet) {
+                logger.always(chalk.red("⚠️ Deleting a session in quiet mode requires --force flag"));
+                logger.always(chalk.yellow(`Usage: neurolink memory delete ${argv.sessionId} --force`));
+                return;
+            }
+            const readline = await import("readline");
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question(chalk.yellow(`⚠️ Are you sure you want to delete session "${argv.sessionId}"? (y/N): `), resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+                logger.always(chalk.gray("Deletion cancelled."));
+                return;
+            }
+        }
+        const spinner = options.quiet
+            ? null
+            : ora(`🗑️ Deleting session ${argv.sessionId}...`).start();
+        try {
+            const sdk = globalSession.getOrCreateNeuroLink();
+            // Handle dry-run mode
+            if (options.dryRun) {
+                if (spinner) {
+                    spinner.succeed(chalk.green(`✅ Session ${argv.sessionId} deleted (dry-run)`));
+                }
+                const result = {
+                    success: true,
+                    action: "delete",
+                    sessionId: argv.sessionId,
+                    message: "Session would be deleted",
+                };
+                CLICommandFactory.handleOutput(result, options);
+                return;
+            }
+            const success = await sdk.clearConversationSession(argv.sessionId);
+            if (spinner) {
+                if (success) {
+                    spinner.succeed(chalk.green(`✅ Session ${argv.sessionId} deleted successfully`));
+                }
+                else {
+                    spinner.warn(chalk.yellow(`⚠️ Session ${argv.sessionId} not found or already deleted`));
+                }
+            }
+            if (options.format === "json") {
+                const result = {
+                    success,
+                    action: "delete",
+                    sessionId: argv.sessionId,
+                };
+                CLICommandFactory.handleOutput(result, options);
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail("Session deletion failed");
+            }
+            if (error.message.includes("not enabled")) {
+                logger.always(chalk.yellow("⚠️ Conversation memory is not enabled"));
+                logger.always("Enable it by using --enable-conversation-memory with loop mode");
+            }
+            else {
+                handleError(error, "Memory delete");
+            }
+        }
+    }
     /**
      * Execute completion command
      */

package/dist/core/conversationMemoryManager.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Manager for NeuroLink
  * Handles in-memory conversation storage, session management, and context injection
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, SessionListItem, SessionMemory, StoreConversationTurnOptions, IConversationMemoryManager } from "../types/index.js";
 export declare class ConversationMemoryManager implements IConversationMemoryManager {
     private sessions;
     config: ConversationMemoryConfig;
@@ -56,6 +56,16 @@ export declare class ConversationMemoryManager implements IConversationMemoryMan
     private createNewSession;
     private enforceSessionLimit;
     getStats(): Promise<ConversationMemoryStats>;
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     clearSession(sessionId: string): Promise<boolean>;
     clearAllSessions(): Promise<void>;
     /**

package/dist/core/conversationMemoryManager.js

@@ -292,6 +292,50 @@ export class ConversationMemoryManager {
             totalTurns,
         };
     }
+    /**
+     * List all sessions with metadata
+     * @param userId - Optional user ID to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    async listSessions(userId) {
+        await this.ensureInitialized();
+        const sessions = Array.from(this.sessions.values());
+        const now = Date.now();
+        return sessions
+            .filter((session) => !userId || session.userId === userId)
+            .map((session) => {
+            const lastActive = this.formatTimeAgo(now - session.lastActivity);
+            return {
+                id: session.sessionId,
+                title: session.sessionId, // In-memory doesn't store title, use sessionId
+                createdAt: new Date(session.createdAt).toISOString(),
+                updatedAt: new Date(session.lastActivity).toISOString(),
+                userId: session.userId,
+                messageCount: session.messages.length,
+                lastActive,
+            };
+        })
+            .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    formatTimeAgo(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days > 1 ? "s" : ""} ago`;
+        }
+        if (hours > 0) {
+            return `${hours} hour${hours > 1 ? "s" : ""} ago`;
+        }
+        if (minutes > 0) {
+            return `${minutes} minute${minutes > 1 ? "s" : ""} ago`;
+        }
+        return "just now";
+    }
     async clearSession(sessionId) {
         return withSpan({
             name: "neurolink.memory.clear",

package/dist/core/redisConversationMemoryManager.d.ts

@@ -2,7 +2,7 @@
  * Redis Conversation Memory Manager for NeuroLink
  * Redis-based implementation of conversation storage with same interface as ConversationMemoryManager
  */
-import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
+import type { ChatMessage, ConversationMemoryConfig, ConversationMemoryStats, RedisConversationObject, RedisStorageConfig, SessionListItem, SessionMemory, SessionMetadata, StoreConversationTurnOptions, AgenticLoopReportMetadata, IConversationMemoryManager } from "../types/index.js";
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -175,6 +175,17 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * @returns Array of session metadata objects
      */
     getUserAllSessionsHistory(userId: string): Promise<SessionMetadata[]>;
+    /**
+     * List all sessions with metadata for CLI/API usage
+     * Implements IConversationMemoryManager.listSessions
+     * @param userId - Optional user identifier to filter sessions
+     * @returns Array of session list items with metadata
+     */
+    listSessions(userId?: string): Promise<SessionListItem[]>;
+    /**
+     * Format milliseconds into human-readable time ago string
+     */
+    private formatTimeAgo;
     /**
      * Clean up stale pending tool execution data
      * Removes data older than 5 minutes to prevent memory leaks