deepthinking-mcp 2.5.4 → 2.5.6

package/dist/index.js

@@ -2,7 +2,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { randomUUID } from 'crypto';
+import { randomUUID, createHash } from 'crypto';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -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"],
@@ -1201,6 +1294,187 @@ function createLogger(config) {
   return new Logger(config);
 }
 
+// src/config/index.ts
+var defaultConfig = {
+  maxThoughtsInMemory: parseInt(process.env.MCP_MAX_THOUGHTS || "1000", 10),
+  compressionThreshold: parseInt(process.env.MCP_COMPRESSION_THRESHOLD || "500", 10),
+  maxContentLength: parseInt(process.env.MCP_MAX_CONTENT_LENGTH || "10000", 10),
+  validationTolerance: parseFloat(process.env.MCP_VALIDATION_TOLERANCE || "0.01"),
+  maxActiveSessions: parseInt(process.env.MCP_MAX_SESSIONS || "100", 10),
+  sessionTimeoutMs: parseInt(process.env.MCP_SESSION_TIMEOUT_MS || "0", 10),
+  enableValidationCache: process.env.MCP_ENABLE_VALIDATION_CACHE !== "false",
+  validationCacheMaxSize: parseInt(process.env.MCP_VALIDATION_CACHE_SIZE || "1000", 10),
+  enablePersistence: process.env.MCP_ENABLE_PERSISTENCE === "true",
+  persistenceDir: process.env.MCP_PERSISTENCE_DIR || "./.deepthinking-sessions",
+  logLevel: process.env.MCP_LOG_LEVEL || "info",
+  enablePerformanceMetrics: process.env.MCP_ENABLE_PERF_METRICS === "true"
+};
+var activeConfig = { ...defaultConfig };
+function getConfig() {
+  return Object.freeze({ ...activeConfig });
+}
+function validateConfig(config) {
+  if (config.maxThoughtsInMemory < 1) {
+    throw new Error("maxThoughtsInMemory must be at least 1");
+  }
+  if (config.compressionThreshold < 0) {
+    throw new Error("compressionThreshold must be non-negative");
+  }
+  if (config.maxContentLength < 1) {
+    throw new Error("maxContentLength must be at least 1");
+  }
+  if (config.validationTolerance < 0 || config.validationTolerance > 1) {
+    throw new Error("validationTolerance must be between 0 and 1");
+  }
+  if (config.maxActiveSessions < 1) {
+    throw new Error("maxActiveSessions must be at least 1");
+  }
+  if (config.sessionTimeoutMs < 0) {
+    throw new Error("sessionTimeoutMs must be non-negative");
+  }
+  if (config.validationCacheMaxSize < 0) {
+    throw new Error("validationCacheMaxSize must be non-negative");
+  }
+  if (!["debug", "info", "warn", "error"].includes(config.logLevel)) {
+    throw new Error("logLevel must be one of: debug, info, warn, error");
+  }
+}
+validateConfig(activeConfig);
+var ValidationCache = class {
+  cache;
+  maxSize;
+  hits = 0;
+  misses = 0;
+  constructor(maxSize) {
+    const config = getConfig();
+    this.maxSize = maxSize || config.validationCacheMaxSize;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Generate a cache key from thought content
+   *
+   * Uses SHA-256 hash of JSON-serialized content for reliable cache keys
+   *
+   * @param content - Content to hash
+   * @returns Cache key
+   */
+  generateKey(content) {
+    const json = JSON.stringify(content);
+    return createHash("sha256").update(json).digest("hex");
+  }
+  /**
+   * Get validation result from cache
+   *
+   * @param content - Content to look up
+   * @returns Cached result or undefined if not found
+   */
+  get(content) {
+    const key = this.generateKey(content);
+    const entry = this.cache.get(key);
+    if (entry) {
+      this.hits++;
+      entry.hitCount++;
+      this.cache.delete(key);
+      this.cache.set(key, entry);
+      return entry;
+    }
+    this.misses++;
+    return void 0;
+  }
+  /**
+   * Store validation result in cache
+   *
+   * @param content - Content that was validated
+   * @param result - Validation result to cache
+   */
+  set(content, result) {
+    const key = this.generateKey(content);
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    const entry = {
+      result,
+      timestamp: Date.now(),
+      hitCount: 0
+    };
+    this.cache.set(key, entry);
+  }
+  /**
+   * Check if content is in cache
+   *
+   * @param content - Content to check
+   * @returns true if cached
+   */
+  has(content) {
+    const key = this.generateKey(content);
+    return this.cache.has(key);
+  }
+  /**
+   * Clear all cached validation results
+   */
+  clear() {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0
+    };
+  }
+  /**
+   * Resize the cache
+   *
+   * @param newSize - New maximum cache size
+   */
+  resize(newSize) {
+    this.maxSize = newSize;
+    if (this.cache.size > newSize) {
+      const keysToDelete = this.cache.size - newSize;
+      const keys = Array.from(this.cache.keys());
+      for (let i = 0; i < keysToDelete; i++) {
+        this.cache.delete(keys[i]);
+      }
+    }
+  }
+  /**
+   * Get entries sorted by hit count (most used first)
+   */
+  getTopEntries(limit = 10) {
+    const entries = Array.from(this.cache.entries()).map(([key, entry]) => ({ key, entry })).sort((a, b) => b.entry.hitCount - a.entry.hitCount);
+    return entries.slice(0, limit);
+  }
+  /**
+   * Remove entries older than a certain age
+   *
+   * @param maxAgeMs - Maximum age in milliseconds
+   * @returns Number of entries removed
+   */
+  evictOld(maxAgeMs) {
+    const now = Date.now();
+    let removed = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > maxAgeMs) {
+        this.cache.delete(key);
+        removed++;
+      }
+    }
+    return removed;
+  }
+};
+var validationCache = new ValidationCache();
+
 // src/session/manager.ts
 var DEFAULT_CONFIG2 = {
   modeConfig: {
@@ -1543,7 +1817,14 @@ var SessionManager = class {
       revisionCount: 0,
       timeSpent: 0,
       dependencyDepth: 0,
-      customMetrics: /* @__PURE__ */ new Map()
+      customMetrics: /* @__PURE__ */ new Map(),
+      cacheStats: {
+        hits: 0,
+        misses: 0,
+        hitRate: 0,
+        size: 0,
+        maxSize: 0
+      }
     };
   }
   /**
@@ -1558,6 +1839,8 @@ var SessionManager = class {
   updateMetrics(session, thought) {
     const metrics = session.metrics;
     metrics.totalThoughts = session.thoughts.length;
+    const thoughtType = thought.type || "unknown";
+    metrics.thoughtsByType[thoughtType] = (metrics.thoughtsByType[thoughtType] || 0) + 1;
     if (thought.isRevision) {
       metrics.revisionCount++;
     }
@@ -1638,6 +1921,22 @@ var SessionManager = class {
         metrics.customMetrics.set("decisions", thought.decisions.length);
       }
     }
+    this.updateCacheStats(session);
+  }
+  /**
+   * Update validation cache statistics in session metrics
+   *
+   * @param session - Session to update
+   */
+  updateCacheStats(session) {
+    const cacheStats = validationCache.getStats();
+    session.metrics.cacheStats = {
+      hits: cacheStats.hits,
+      misses: cacheStats.misses,
+      hitRate: cacheStats.hitRate,
+      size: cacheStats.size,
+      maxSize: cacheStats.maxSize
+    };
   }
 };
 
@@ -2085,6 +2384,52 @@ Bayes Factor: ${thought.bayesFactor.toFixed(2)}
   }
 };
 
+// src/utils/type-guards.ts
+var VALID_THOUGHT_TYPES = [
+  "problem_definition",
+  "constraints",
+  "model",
+  "proof",
+  "implementation",
+  "axiom_definition",
+  "theorem_statement",
+  "proof_construction",
+  "lemma_derivation",
+  "corollary",
+  "counterexample",
+  "algebraic_manipulation",
+  "symbolic_computation",
+  "numerical_analysis",
+  "symmetry_analysis",
+  "gauge_theory",
+  "field_equations",
+  "lagrangian",
+  "hamiltonian",
+  "conservation_law",
+  "dimensional_analysis",
+  "tensor_formulation",
+  "differential_geometry",
+  "decomposition",
+  "synthesis",
+  "abstraction",
+  "analogy",
+  "metacognition"
+];
+function isExtendedThoughtType(value) {
+  return typeof value === "string" && VALID_THOUGHT_TYPES.includes(value);
+}
+function toExtendedThoughtType(value, fallback) {
+  if (isExtendedThoughtType(value)) {
+    return value;
+  }
+  if (fallback !== void 0) {
+    return fallback;
+  }
+  throw new Error(
+    `Invalid ExtendedThoughtType: ${value}. Must be one of: ${VALID_THOUGHT_TYPES.join(", ")}`
+  );
+}
+
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
@@ -2351,7 +2696,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "mathematics" /* MATHEMATICS */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "model"),
         mathematicalModel: input.mathematicalModel,
         proofStrategy: input.proofStrategy,
         dependencies: input.dependencies || [],
@@ -2362,7 +2707,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "physics" /* PHYSICS */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "model"),
         tensorProperties: input.tensorProperties,
         physicalInterpretation: input.physicalInterpretation,
         dependencies: input.dependencies || [],
@@ -2373,7 +2718,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "abductive" /* ABDUCTIVE */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         observations: input.observations || [],
         hypotheses: input.hypotheses || [],
         evaluationCriteria: input.evaluationCriteria,
@@ -2384,7 +2729,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "causal" /* CAUSAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         causalGraph: input.causalGraph,
         interventions: input.interventions || [],
         mechanisms: input.mechanisms || [],
@@ -2394,7 +2739,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "bayesian" /* BAYESIAN */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         hypothesis: input.hypothesis,
         prior: input.prior,
         likelihood: input.likelihood,
@@ -2406,7 +2751,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "counterfactual" /* COUNTERFACTUAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "problem_definition"),
         actual: input.actual,
         counterfactuals: input.counterfactuals || [],
         comparison: input.comparison,
@@ -2417,7 +2762,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "analogical" /* ANALOGICAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "analogy"),
         sourceDomain: input.sourceDomain,
         targetDomain: input.targetDomain,
         mapping: input.mapping || [],
@@ -2430,7 +2775,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "temporal" /* TEMPORAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: input.thoughtType || "event_definition",
         timeline: input.timeline,
         events: input.events || [],
         intervals: input.intervals || [],
@@ -2441,7 +2786,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "gametheory" /* GAMETHEORY */,
-        thoughtType: input.thoughtType,
+        thoughtType: input.thoughtType || "game_definition",
         game: input.game,
         players: input.players || [],
         strategies: input.strategies || [],
@@ -2454,7 +2799,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "evidential" /* EVIDENTIAL */,
-        thoughtType: input.thoughtType,
+        thoughtType: input.thoughtType || "hypothesis_definition",
         frameOfDiscernment: input.frameOfDiscernment,
         hypotheses: input.hypotheses || [],
         evidence: input.evidence || [],
@@ -2468,7 +2813,7 @@ function createThought(input, sessionId) {
       return {
         ...baseThought,
         mode: "hybrid" /* HYBRID */,
-        thoughtType: input.thoughtType,
+        thoughtType: toExtendedThoughtType(input.thoughtType, "synthesis"),
         stage: input.stage,
         uncertainty: input.uncertainty,
         dependencies: input.dependencies,
@@ -2476,7 +2821,7 @@ function createThought(input, sessionId) {
         mathematicalModel: input.mathematicalModel,
         tensorProperties: input.tensorProperties,
         physicalInterpretation: input.physicalInterpretation,
-        primaryMode: input.mode,
+        primaryMode: input.mode || "hybrid" /* HYBRID */,
         secondaryFeatures: []
       };
   }