deepthinking-mcp 2.5.5 → 2.6.0

package/dist/index.js

@@ -442,7 +442,7 @@ Phase 3 Modes (v2.1+):
 Actions:
 - add_thought: Add a new thought to the session (default)
 - summarize: Generate a summary of the session
-- export: Export session in various formats (markdown, latex, json, html, jupyter)
+- export: Export session in various formats (markdown, latex, json, html, jupyter, mermaid, dot, ascii)
 - switch_mode: Change reasoning mode mid-session
 - get_session: Retrieve session information
 - recommend_mode: Get intelligent mode recommendations based on problem characteristics
@@ -709,6 +709,99 @@ Choose the mode that best fits your problem type, or use recommend_mode to get i
         },
         description: "Temporal causal/enabling relations"
       },
+      // Game theory properties (Phase 3, v2.2)
+      players: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            role: { type: "string" },
+            isRational: { type: "boolean" },
+            availableStrategies: {
+              type: "array",
+              items: { type: "string" }
+            }
+          },
+          required: ["id", "name", "isRational", "availableStrategies"]
+        },
+        description: "Players in the game"
+      },
+      strategies: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            playerId: { type: "string" },
+            name: { type: "string" },
+            description: { type: "string" },
+            isPure: { type: "boolean" },
+            probability: { type: "number", minimum: 0, maximum: 1 }
+          },
+          required: ["id", "playerId", "name", "description", "isPure"]
+        },
+        description: "Available strategies"
+      },
+      payoffMatrix: {
+        type: "object",
+        properties: {
+          players: {
+            type: "array",
+            items: { type: "string" }
+          },
+          dimensions: {
+            type: "array",
+            items: { type: "number" }
+          },
+          payoffs: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                strategyProfile: {
+                  type: "array",
+                  items: { type: "string" }
+                },
+                payoffs: {
+                  type: "array",
+                  items: { type: "number" }
+                }
+              },
+              required: ["strategyProfile", "payoffs"]
+            }
+          }
+        },
+        required: ["players", "dimensions", "payoffs"],
+        description: "Payoff matrix for the game"
+      },
+      // Evidential reasoning properties (Phase 3, v2.3)
+      frameOfDiscernment: {
+        type: "array",
+        items: { type: "string" },
+        description: "Frame of discernment (set of all possible hypotheses)"
+      },
+      beliefMasses: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            hypothesisSet: {
+              type: "array",
+              items: { type: "string" }
+            },
+            mass: {
+              type: "number",
+              minimum: 0,
+              maximum: 1
+            },
+            justification: { type: "string" }
+          },
+          required: ["hypothesisSet", "mass", "justification"]
+        },
+        description: "Belief mass assignments (Dempster-Shafer)"
+      },
       action: {
         type: "string",
         enum: ["add_thought", "summarize", "export", "switch_mode", "get_session", "recommend_mode"],
@@ -1402,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
@@ -1471,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,
@@ -1483,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
@@ -1498,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
@@ -1549,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,
@@ -1588,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,
@@ -1599,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
@@ -1612,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,
@@ -1622,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
@@ -1638,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 });
     }
   }
   /**