deepthinking-mcp 2.5.6 → 2.6.0

package/dist/index.js

@@ -1495,23 +1495,33 @@ var SessionManager = class {
   activeSessions;
   config;
   logger;
+  storage;
   /**
    * Creates a new SessionManager instance
    *
    * @param config - Optional default configuration applied to all new sessions
    * @param logLevel - Optional minimum log level (default: INFO)
+   * @param storage - Optional persistent storage backend for sessions
    *
    * @example
    * ```typescript
+   * // Memory-only mode (default)
    * const manager = new SessionManager({
    *   enableAutoSave: true,
    *   maxThoughtsInMemory: 500
    * }, LogLevel.DEBUG);
+   *
+   * // With file-based persistence
+   * import { FileSessionStore } from './storage/file-store.js';
+   * const storage = new FileSessionStore('./sessions');
+   * await storage.initialize();
+   * const manager = new SessionManager({}, LogLevel.INFO, storage);
    * ```
    */
-  constructor(config, logLevel) {
+  constructor(config, logLevel, storage) {
     this.activeSessions = /* @__PURE__ */ new Map();
     this.config = config || {};
+    this.storage = storage;
     this.logger = createLogger({
       minLevel: logLevel || 1 /* INFO */,
       enableConsole: true
@@ -1564,6 +1574,14 @@ var SessionManager = class {
       collaborators: author ? [author] : []
     };
     this.activeSessions.set(sessionId, session);
+    if (this.storage && session.config.enableAutoSave) {
+      try {
+        await this.storage.saveSession(session);
+        this.logger.debug("Session persisted to storage", { sessionId });
+      } catch (error) {
+        this.logger.error("Failed to persist session", error, { sessionId });
+      }
+    }
     this.logger.info("Session created", {
       sessionId,
       title,
@@ -1576,7 +1594,8 @@ var SessionManager = class {
   /**
    * Get a session by ID
    *
-   * Retrieves an active session by its unique identifier.
+   * Retrieves a session by its unique identifier. If the session is not in memory
+   * but storage is available, it will attempt to load from storage.
    *
    * @param sessionId - Unique UUID v4 identifier of the session
    * @returns Promise resolving to the session, or null if not found
@@ -1591,7 +1610,19 @@ var SessionManager = class {
    * ```
    */
   async getSession(sessionId) {
-    return this.activeSessions.get(sessionId) || null;
+    let session = this.activeSessions.get(sessionId);
+    if (!session && this.storage) {
+      try {
+        session = await this.storage.loadSession(sessionId);
+        if (session) {
+          this.activeSessions.set(sessionId, session);
+          this.logger.debug("Session loaded from storage", { sessionId });
+        }
+      } catch (error) {
+        this.logger.error("Failed to load session from storage", error, { sessionId });
+      }
+    }
+    return session || null;
   }
   /**
    * Add a thought to a session
@@ -1642,6 +1673,14 @@ var SessionManager = class {
         totalThoughts: session.thoughts.length
       });
     }
+    if (this.storage && session.config.enableAutoSave) {
+      try {
+        await this.storage.saveSession(session);
+        this.logger.debug("Session persisted after thought added", { sessionId });
+      } catch (error) {
+        this.logger.error("Failed to persist session", error, { sessionId });
+      }
+    }
     this.logger.debug("Thought added", {
       sessionId,
       thoughtNumber: thought.thoughtNumber,
@@ -1681,6 +1720,14 @@ var SessionManager = class {
     session.mode = newMode;
     session.config.modeConfig.mode = newMode;
     session.updatedAt = /* @__PURE__ */ new Date();
+    if (this.storage && session.config.enableAutoSave) {
+      try {
+        await this.storage.saveSession(session);
+        this.logger.debug("Session persisted after mode switch", { sessionId });
+      } catch (error) {
+        this.logger.error("Failed to persist session", error, { sessionId });
+      }
+    }
     this.logger.info("Session mode switched", {
       sessionId,
       oldMode,
@@ -1692,9 +1739,10 @@ var SessionManager = class {
   /**
    * List all active sessions with metadata
    *
-   * Returns summary information for all sessions currently managed
-   * by this SessionManager instance.
+   * Returns summary information for all sessions. If storage is available,
+   * includes both in-memory sessions and persisted sessions.
    *
+   * @param includeStoredSessions - Whether to include sessions from storage (default: true)
    * @returns Promise resolving to array of session metadata
    *
    * @example
@@ -1705,8 +1753,8 @@ var SessionManager = class {
    * });
    * ```
    */
-  async listSessions() {
-    return Array.from(this.activeSessions.values()).map((session) => ({
+  async listSessions(includeStoredSessions = true) {
+    const memoryMetadata = Array.from(this.activeSessions.values()).map((session) => ({
       id: session.id,
       title: session.title,
       createdAt: session.createdAt,
@@ -1715,11 +1763,27 @@ var SessionManager = class {
       mode: session.mode,
       isComplete: session.isComplete
     }));
+    if (!this.storage || !includeStoredSessions) {
+      return memoryMetadata;
+    }
+    try {
+      const storedMetadata = await this.storage.listSessions();
+      const memoryIds = new Set(memoryMetadata.map((s) => s.id));
+      const combined = [
+        ...memoryMetadata,
+        ...storedMetadata.filter((s) => !memoryIds.has(s.id))
+      ];
+      return combined;
+    } catch (error) {
+      this.logger.error("Failed to list stored sessions", error);
+      return memoryMetadata;
+    }
   }
   /**
    * Delete a session
    *
-   * Removes a session from memory. This operation cannot be undone.
+   * Removes a session from memory and storage (if available).
+   * This operation cannot be undone.
    *
    * @param sessionId - ID of the session to delete
    * @returns Promise that resolves when deletion is complete
@@ -1731,15 +1795,23 @@ var SessionManager = class {
    */
   async deleteSession(sessionId) {
     const session = this.activeSessions.get(sessionId);
-    const deleted = this.activeSessions.delete(sessionId);
-    if (deleted && session) {
+    const deletedFromMemory = this.activeSessions.delete(sessionId);
+    if (this.storage) {
+      try {
+        await this.storage.deleteSession(sessionId);
+        this.logger.debug("Session deleted from storage", { sessionId });
+      } catch (error) {
+        this.logger.error("Failed to delete session from storage", error, { sessionId });
+      }
+    }
+    if (deletedFromMemory && session) {
       this.logger.info("Session deleted", {
         sessionId,
         title: session.title,
         thoughtCount: session.thoughts.length
       });
     } else {
-      this.logger.warn("Attempted to delete non-existent session", { sessionId });
+      this.logger.warn("Attempted to delete non-existent session from memory", { sessionId });
     }
   }
   /**