deepthinking-mcp 2.4.1 → 2.5.0

package/dist/index.js

@@ -395,7 +395,7 @@ var ThinkingToolSchema = z.object({
     }))
   })).optional(),
   action: z.enum(["add_thought", "summarize", "export", "switch_mode", "get_session", "recommend_mode"]).default("add_thought"),
-  exportFormat: z.enum(["markdown", "latex", "json", "html", "jupyter"]).optional(),
+  exportFormat: z.enum(["markdown", "latex", "json", "html", "jupyter", "mermaid", "dot", "ascii"]).optional(),
   newMode: z.enum(["sequential", "shannon", "mathematics", "physics", "hybrid", "abductive", "causal", "bayesian", "counterfactual", "analogical", "temporal", "gametheory", "evidential"]).optional(),
   // Mode recommendation parameters (v2.4)
   problemType: z.string().optional(),
@@ -436,7 +436,21 @@ Phase 3 Modes (v2.1+):
 - gametheory: Nash equilibria, strategic analysis, payoff matrices
 - evidential: Dempster-Shafer theory, belief functions, evidence combination
 
-Choose the mode that best fits your problem type.`,
+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)
+- switch_mode: Change reasoning mode mid-session
+- get_session: Retrieve session information
+- recommend_mode: Get intelligent mode recommendations based on problem characteristics
+
+Mode Recommendations (v2.4):
+Use action 'recommend_mode' with either:
+  \u2022 problemType: Quick recommendation (e.g., 'debugging', 'proof', 'timeline', 'strategy')
+  \u2022 problemCharacteristics: Detailed analysis with 10 dimensions (domain, complexity, uncertainty, etc.)
+  \u2022 includeCombinations: Set to true for synergistic mode combination suggestions
+
+Choose the mode that best fits your problem type, or use recommend_mode to get intelligent suggestions.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -699,7 +713,7 @@ Choose the mode that best fits your problem type.`,
       },
       exportFormat: {
         type: "string",
-        enum: ["markdown", "latex", "json", "html", "jupyter"],
+        enum: ["markdown", "latex", "json", "html", "jupyter", "mermaid", "dot", "ascii"],
         description: "Export format"
       },
       newMode: {
@@ -1218,6 +1232,450 @@ var SessionManager = class {
   }
 };
 
+// src/export/visual.ts
+var VisualExporter = class {
+  /**
+   * Export causal graph to visual format
+   */
+  exportCausalGraph(thought, options) {
+    const { format, colorScheme = "default", includeLabels = true, includeMetrics = true } = options;
+    switch (format) {
+      case "mermaid":
+        return this.causalGraphToMermaid(thought, colorScheme, includeLabels, includeMetrics);
+      case "dot":
+        return this.causalGraphToDOT(thought, includeLabels, includeMetrics);
+      case "ascii":
+        return this.causalGraphToASCII(thought);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Export temporal timeline to visual format
+   */
+  exportTemporalTimeline(thought, options) {
+    const { format, colorScheme = "default", includeLabels = true } = options;
+    switch (format) {
+      case "mermaid":
+        return this.timelineToMermaidGantt(thought, includeLabels);
+      case "dot":
+        return this.timelineToDOT(thought, includeLabels);
+      case "ascii":
+        return this.timelineToASCII(thought);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Export game tree to visual format
+   */
+  exportGameTree(thought, options) {
+    const { format, colorScheme = "default", includeLabels = true, includeMetrics = true } = options;
+    switch (format) {
+      case "mermaid":
+        return this.gameTreeToMermaid(thought, colorScheme, includeLabels, includeMetrics);
+      case "dot":
+        return this.gameTreeToDOT(thought, includeLabels, includeMetrics);
+      case "ascii":
+        return this.gameTreeToASCII(thought);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Export Bayesian network to visual format
+   */
+  exportBayesianNetwork(thought, options) {
+    const { format, colorScheme = "default", includeLabels = true, includeMetrics = true } = options;
+    switch (format) {
+      case "mermaid":
+        return this.bayesianToMermaid(thought, colorScheme, includeLabels, includeMetrics);
+      case "dot":
+        return this.bayesianToDOT(thought, includeLabels, includeMetrics);
+      case "ascii":
+        return this.bayesianToASCII(thought);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+  // ===== Causal Graph Exporters =====
+  causalGraphToMermaid(thought, colorScheme, includeLabels, includeMetrics) {
+    let mermaid = "graph TB\n";
+    for (const node of thought.causalGraph.nodes) {
+      const nodeId = this.sanitizeId(node.id);
+      const label = includeLabels ? node.name : nodeId;
+      let shape;
+      switch (node.type) {
+        case "cause":
+          shape = ["([", "])"];
+          break;
+        case "effect":
+          shape = ["[[", "]]"];
+          break;
+        case "mediator":
+          shape = ["[", "]"];
+          break;
+        case "confounder":
+          shape = ["{", "}"];
+          break;
+        default:
+          shape = ["[", "]"];
+      }
+      mermaid += `  ${nodeId}${shape[0]}${label}${shape[1]}
+`;
+    }
+    mermaid += "\n";
+    for (const edge of thought.causalGraph.edges) {
+      const fromId = this.sanitizeId(edge.from);
+      const toId = this.sanitizeId(edge.to);
+      if (includeMetrics && edge.strength !== void 0) {
+        mermaid += `  ${fromId} --> |${edge.strength.toFixed(2)}| ${toId}
+`;
+      } else {
+        mermaid += `  ${fromId} --> ${toId}
+`;
+      }
+    }
+    if (colorScheme !== "monochrome") {
+      mermaid += "\n";
+      const causes = thought.causalGraph.nodes.filter((n) => n.type === "cause");
+      const effects = thought.causalGraph.nodes.filter((n) => n.type === "effect");
+      for (const node of causes) {
+        const color = colorScheme === "pastel" ? "#e1f5ff" : "#a8d5ff";
+        mermaid += `  style ${this.sanitizeId(node.id)} fill:${color}
+`;
+      }
+      for (const node of effects) {
+        const color = colorScheme === "pastel" ? "#fff3e0" : "#ffd699";
+        mermaid += `  style ${this.sanitizeId(node.id)} fill:${color}
+`;
+      }
+    }
+    return mermaid;
+  }
+  causalGraphToDOT(thought, includeLabels, includeMetrics) {
+    let dot = "digraph CausalGraph {\n";
+    dot += "  rankdir=TB;\n";
+    dot += "  node [shape=box, style=rounded];\n\n";
+    for (const node of thought.causalGraph.nodes) {
+      const nodeId = this.sanitizeId(node.id);
+      const label = includeLabels ? node.name : nodeId;
+      let shape = "box";
+      switch (node.type) {
+        case "cause":
+          shape = "ellipse";
+          break;
+        case "effect":
+          shape = "doubleoctagon";
+          break;
+        case "mediator":
+          shape = "box";
+          break;
+        case "confounder":
+          shape = "diamond";
+          break;
+      }
+      dot += `  ${nodeId} [label="${label}", shape=${shape}];
+`;
+    }
+    dot += "\n";
+    for (const edge of thought.causalGraph.edges) {
+      const fromId = this.sanitizeId(edge.from);
+      const toId = this.sanitizeId(edge.to);
+      if (includeMetrics && edge.strength !== void 0) {
+        dot += `  ${fromId} -> ${toId} [label="${edge.strength.toFixed(2)}"];
+`;
+      } else {
+        dot += `  ${fromId} -> ${toId};
+`;
+      }
+    }
+    dot += "}\n";
+    return dot;
+  }
+  causalGraphToASCII(thought) {
+    let ascii = "Causal Graph:\n";
+    ascii += "=============\n\n";
+    ascii += "Nodes:\n";
+    for (const node of thought.causalGraph.nodes) {
+      ascii += `  [${node.type.toUpperCase()}] ${node.name}: ${node.description}
+`;
+    }
+    ascii += "\nEdges:\n";
+    for (const edge of thought.causalGraph.edges) {
+      const fromNode = thought.causalGraph.nodes.find((n) => n.id === edge.from);
+      const toNode = thought.causalGraph.nodes.find((n) => n.id === edge.to);
+      const strength = edge.strength !== void 0 ? ` (strength: ${edge.strength.toFixed(2)})` : "";
+      ascii += `  ${fromNode?.name} --> ${toNode?.name}${strength}
+`;
+    }
+    return ascii;
+  }
+  // ===== Temporal Timeline Exporters =====
+  timelineToMermaidGantt(thought, includeLabels) {
+    let gantt = "gantt\n";
+    gantt += `  title ${thought.timeline?.name || "Timeline"}
+`;
+    gantt += "  dateFormat X\n";
+    gantt += "  axisFormat %s\n\n";
+    if (!thought.events || thought.events.length === 0) {
+      return gantt + "  No events\n";
+    }
+    gantt += "  section Events\n";
+    for (const event of thought.events) {
+      const label = includeLabels ? event.name : event.id;
+      if (event.type === "instant") {
+        gantt += `  ${label} :milestone, ${event.timestamp}, 0s
+`;
+      } else if (event.type === "interval" && event.duration) {
+        gantt += `  ${label} :${event.timestamp}, ${event.duration}s
+`;
+      }
+    }
+    return gantt;
+  }
+  timelineToDOT(thought, includeLabels) {
+    let dot = "digraph Timeline {\n";
+    dot += "  rankdir=LR;\n";
+    dot += "  node [shape=box];\n\n";
+    if (!thought.events) {
+      dot += "}\n";
+      return dot;
+    }
+    const sortedEvents = [...thought.events].sort((a, b) => a.timestamp - b.timestamp);
+    for (const event of sortedEvents) {
+      const nodeId = this.sanitizeId(event.id);
+      const label = includeLabels ? `${event.name}\\n(t=${event.timestamp})` : nodeId;
+      const shape = event.type === "instant" ? "ellipse" : "box";
+      dot += `  ${nodeId} [label="${label}", shape=${shape}];
+`;
+    }
+    dot += "\n";
+    for (let i = 0; i < sortedEvents.length - 1; i++) {
+      const from = this.sanitizeId(sortedEvents[i].id);
+      const to = this.sanitizeId(sortedEvents[i + 1].id);
+      dot += `  ${from} -> ${to};
+`;
+    }
+    if (thought.relations) {
+      dot += "\n  // Causal relations\n";
+      for (const rel of thought.relations) {
+        const from = this.sanitizeId(rel.from);
+        const to = this.sanitizeId(rel.to);
+        dot += `  ${from} -> ${to} [style=dashed, label="${rel.relationType}"];
+`;
+      }
+    }
+    dot += "}\n";
+    return dot;
+  }
+  timelineToASCII(thought) {
+    let ascii = `Timeline: ${thought.timeline?.name || "Untitled"}
+`;
+    ascii += "=".repeat(40) + "\n\n";
+    if (!thought.events || thought.events.length === 0) {
+      return ascii + "No events\n";
+    }
+    const sortedEvents = [...thought.events].sort((a, b) => a.timestamp - b.timestamp);
+    for (const event of sortedEvents) {
+      const marker = event.type === "instant" ? "\u29BF" : "\u2501";
+      ascii += `t=${event.timestamp.toString().padStart(4)} ${marker} ${event.name}
+`;
+      if (event.duration) {
+        ascii += `       ${"\u2514".padStart(5)}\u2192 duration: ${event.duration}
+`;
+      }
+    }
+    return ascii;
+  }
+  // ===== Game Theory Exporters =====
+  gameTreeToMermaid(thought, colorScheme, includeLabels, includeMetrics) {
+    let mermaid = "graph TD\n";
+    if (!thought.game) {
+      return mermaid + "  root[No game defined]\n";
+    }
+    if (thought.gameTree && thought.gameTree.nodes) {
+      for (const node of thought.gameTree.nodes) {
+        const nodeId = this.sanitizeId(node.id);
+        const label = includeLabels ? node.name : nodeId;
+        const shape = node.isTerminal ? ["[[", "]]"] : ["[", "]"];
+        mermaid += `  ${nodeId}${shape[0]}${label}${shape[1]}
+`;
+      }
+      mermaid += "\n";
+      for (const node of thought.gameTree.nodes) {
+        if (node.childNodes && node.childNodes.length > 0) {
+          for (const childId of node.childNodes) {
+            const fromId = this.sanitizeId(node.id);
+            const toId = this.sanitizeId(childId);
+            const childNode = thought.gameTree.nodes.find((n) => n.id === childId);
+            if (includeMetrics && childNode?.action) {
+              mermaid += `  ${fromId} --> |${childNode.action}| ${toId}
+`;
+            } else {
+              mermaid += `  ${fromId} --> ${toId}
+`;
+            }
+          }
+        }
+      }
+    } else {
+      mermaid += "  root[Game]\n";
+      if (thought.strategies) {
+        for (const strategy of thought.strategies.slice(0, 5)) {
+          const stratId = this.sanitizeId(strategy.id);
+          mermaid += `  root --> ${stratId}[${strategy.name}]
+`;
+        }
+      }
+    }
+    return mermaid;
+  }
+  gameTreeToDOT(thought, includeLabels, includeMetrics) {
+    let dot = "digraph GameTree {\n";
+    dot += "  rankdir=TD;\n";
+    dot += "  node [shape=circle];\n\n";
+    if (!thought.game) {
+      dot += '  root [label="No game"];\n}\n';
+      return dot;
+    }
+    if (thought.gameTree && thought.gameTree.nodes) {
+      for (const node of thought.gameTree.nodes) {
+        const nodeId = this.sanitizeId(node.id);
+        const label = includeLabels ? node.name : nodeId;
+        const shape = node.isTerminal ? "doublecircle" : "circle";
+        dot += `  ${nodeId} [label="${label}", shape=${shape}];
+`;
+      }
+      dot += "\n";
+      for (const node of thought.gameTree.nodes) {
+        if (node.childNodes && node.childNodes.length > 0) {
+          for (const childId of node.childNodes) {
+            const fromId = this.sanitizeId(node.id);
+            const toId = this.sanitizeId(childId);
+            const childNode = thought.gameTree.nodes.find((n) => n.id === childId);
+            if (includeMetrics && childNode?.action) {
+              dot += `  ${fromId} -> ${toId} [label="${childNode.action}"];
+`;
+            } else {
+              dot += `  ${fromId} -> ${toId};
+`;
+            }
+          }
+        }
+      }
+    }
+    dot += "}\n";
+    return dot;
+  }
+  gameTreeToASCII(thought) {
+    let ascii = `Game: ${thought.game?.name || "Untitled"}
+`;
+    ascii += "=".repeat(40) + "\n\n";
+    if (thought.strategies && thought.strategies.length > 0) {
+      ascii += "Strategies:\n";
+      for (const strategy of thought.strategies) {
+        ascii += `  \u2022 ${strategy.name} (${strategy.type})
+`;
+      }
+    }
+    if (thought.equilibria && thought.equilibria.length > 0) {
+      ascii += "\nEquilibria:\n";
+      for (const eq of thought.equilibria) {
+        ascii += `  \u2696 ${eq.type}: ${eq.strategyProfile.join(", ")}
+`;
+        ascii += `    Payoffs: [${eq.payoffs.join(", ")}]
+`;
+      }
+    }
+    return ascii;
+  }
+  // ===== Bayesian Network Exporters =====
+  bayesianToMermaid(thought, colorScheme, includeLabels, includeMetrics) {
+    let mermaid = "graph LR\n";
+    mermaid += `  H([Hypothesis])
+`;
+    mermaid += `  Prior[Prior: ${includeMetrics ? thought.prior.probability.toFixed(3) : "?"}]
+`;
+    mermaid += `  Evidence[Evidence]
+`;
+    mermaid += `  Posterior[[Posterior: ${includeMetrics ? thought.posterior.probability.toFixed(3) : "?"}]]
+`;
+    mermaid += "\n";
+    mermaid += "  Prior --> H\n";
+    mermaid += "  Evidence --> H\n";
+    mermaid += "  H --> Posterior\n";
+    if (colorScheme !== "monochrome") {
+      mermaid += "\n";
+      const priorColor = colorScheme === "pastel" ? "#e1f5ff" : "#a8d5ff";
+      const posteriorColor = colorScheme === "pastel" ? "#c8e6c9" : "#81c784";
+      mermaid += `  style Prior fill:${priorColor}
+`;
+      mermaid += `  style Posterior fill:${posteriorColor}
+`;
+    }
+    return mermaid;
+  }
+  bayesianToDOT(thought, includeLabels, includeMetrics) {
+    let dot = "digraph BayesianNetwork {\n";
+    dot += "  rankdir=LR;\n";
+    dot += "  node [shape=ellipse];\n\n";
+    const priorProb = includeMetrics ? `: ${thought.prior.probability.toFixed(3)}` : "";
+    const posteriorProb = includeMetrics ? `: ${thought.posterior.probability.toFixed(3)}` : "";
+    dot += `  Prior [label="Prior${priorProb}"];
+`;
+    dot += `  Hypothesis [label="Hypothesis", shape=box];
+`;
+    dot += `  Evidence [label="Evidence"];
+`;
+    dot += `  Posterior [label="Posterior${posteriorProb}", shape=doublecircle];
+`;
+    dot += "\n";
+    dot += "  Prior -> Hypothesis;\n";
+    dot += "  Evidence -> Hypothesis;\n";
+    dot += "  Hypothesis -> Posterior;\n";
+    dot += "}\n";
+    return dot;
+  }
+  bayesianToASCII(thought) {
+    let ascii = "Bayesian Network:\n";
+    ascii += "=================\n\n";
+    ascii += `Hypothesis: ${thought.hypothesis.statement}
+
+`;
+    ascii += `Prior Probability: ${thought.prior.probability.toFixed(3)}
+`;
+    ascii += `  Justification: ${thought.prior.justification}
+
+`;
+    if (thought.evidence && thought.evidence.length > 0) {
+      ascii += "Evidence:\n";
+      for (const ev of thought.evidence) {
+        ascii += `  \u2022 ${ev.observation}
+`;
+      }
+      ascii += "\n";
+    }
+    ascii += `Posterior Probability: ${thought.posterior.probability.toFixed(3)}
+`;
+    ascii += `  Justification: ${thought.posterior.justification}
+`;
+    if (thought.bayesFactor !== void 0) {
+      ascii += `
+Bayes Factor: ${thought.bayesFactor.toFixed(2)}
+`;
+    }
+    return ascii;
+  }
+  // ===== Utility Methods =====
+  /**
+   * Sanitize ID for use in diagram formats
+   */
+  sanitizeId(id) {
+    return id.replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+};
+
 // src/index.ts
 var server = new Server(
   {
@@ -1321,6 +1779,50 @@ async function handleExport(input) {
   if (!session) {
     throw new Error(`Session ${input.sessionId} not found`);
   }
+  const format = input.exportFormat || "json";
+  if (format === "mermaid" || format === "dot" || format === "ascii") {
+    const visualExporter = new VisualExporter();
+    const lastThought = session.thoughts[session.thoughts.length - 1];
+    if (!lastThought) {
+      throw new Error("No thoughts in session to export");
+    }
+    let exported2;
+    if (lastThought.mode === "causal" && "causalGraph" in lastThought) {
+      exported2 = visualExporter.exportCausalGraph(lastThought, {
+        format,
+        colorScheme: "default",
+        includeLabels: true,
+        includeMetrics: true
+      });
+    } else if (lastThought.mode === "temporal" && "timeline" in lastThought) {
+      exported2 = visualExporter.exportTemporalTimeline(lastThought, {
+        format,
+        includeLabels: true
+      });
+    } else if (lastThought.mode === "gametheory" && "game" in lastThought) {
+      exported2 = visualExporter.exportGameTree(lastThought, {
+        format,
+        colorScheme: "default",
+        includeLabels: true,
+        includeMetrics: true
+      });
+    } else if (lastThought.mode === "bayesian" && "hypothesis" in lastThought) {
+      exported2 = visualExporter.exportBayesianNetwork(lastThought, {
+        format,
+        colorScheme: "default",
+        includeLabels: true,
+        includeMetrics: true
+      });
+    } else {
+      throw new Error(`Visual export not supported for mode: ${lastThought.mode}`);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: exported2
+      }]
+    };
+  }
   const sessionWithCustomMetrics = {
     ...session,
     metrics: {
@@ -1328,14 +1830,31 @@ async function handleExport(input) {
       customMetrics: Object.fromEntries(session.metrics.customMetrics)
     }
   };
-  const exported = JSON.stringify(sessionWithCustomMetrics, null, 2);
+  let exported;
+  switch (format) {
+    case "json":
+      exported = JSON.stringify(sessionWithCustomMetrics, null, 2);
+      break;
+    case "markdown":
+      exported = exportToMarkdown(sessionWithCustomMetrics);
+      break;
+    case "latex":
+      exported = exportToLatex(sessionWithCustomMetrics);
+      break;
+    case "html":
+      exported = exportToHTML(sessionWithCustomMetrics);
+      break;
+    case "jupyter":
+      exported = exportToJupyter(sessionWithCustomMetrics);
+      break;
+    default:
+      exported = JSON.stringify(sessionWithCustomMetrics, null, 2);
+  }
   return {
-    content: [
-      {
-        type: "text",
-        text: exported
-      }
-    ]
+    content: [{
+      type: "text",
+      text: exported
+    }]
   };
 }
 async function handleSwitchMode(input) {
@@ -1634,6 +2153,123 @@ For more detailed recommendations, provide problemCharacteristics.`
     isError: true
   };
 }
+function exportToMarkdown(session) {
+  let md = `# Thinking Session: ${session.id}
+
+`;
+  md += `**Mode**: ${session.mode}
+`;
+  md += `**Created**: ${session.createdAt}
+`;
+  md += `**Status**: ${session.status}
+
+`;
+  md += `## Thoughts
+
+`;
+  for (const thought of session.thoughts) {
+    md += `### Thought ${thought.thoughtNumber}/${session.thoughts.length}
+
+`;
+    md += `${thought.content}
+
+`;
+  }
+  return md;
+}
+function exportToLatex(session) {
+  let latex = `documentclass{article}
+`;
+  latex += `	itle{Thinking Session: ${session.id}}
+`;
+  latex += `\begin{document}
+`;
+  latex += `maketitle
+
+`;
+  latex += `section{Session Details}
+`;
+  latex += `Mode: ${session.mode}\\
+`;
+  latex += `Status: ${session.status}\\
+
+`;
+  latex += `section{Thoughts}
+`;
+  for (const thought of session.thoughts) {
+    latex += `subsection{Thought ${thought.thoughtNumber}}
+`;
+    latex += `${thought.content}
+
+`;
+  }
+  latex += `end{document}
+`;
+  return latex;
+}
+function exportToHTML(session) {
+  let html = `<!DOCTYPE html>
+<html>
+<head>
+`;
+  html += `  <title>Thinking Session: ${session.id}</title>
+`;
+  html += `  <style>body { font-family: Arial, sans-serif; max-width: 800px; margin: 50px auto; }</style>
+`;
+  html += `</head>
+<body>
+`;
+  html += `  <h1>Thinking Session: ${session.id}</h1>
+`;
+  html += `  <p><strong>Mode:</strong> ${session.mode}</p>
+`;
+  html += `  <p><strong>Status:</strong> ${session.status}</p>
+`;
+  html += `  <h2>Thoughts</h2>
+`;
+  for (const thought of session.thoughts) {
+    html += `  <div>
+`;
+    html += `    <h3>Thought ${thought.thoughtNumber}/${session.thoughts.length}</h3>
+`;
+    html += `    <p>${thought.content}</p>
+`;
+    html += `  </div>
+`;
+  }
+  html += `</body>
+</html>
+`;
+  return html;
+}
+function exportToJupyter(session) {
+  const notebook = {
+    cells: [],
+    metadata: {},
+    nbformat: 4,
+    nbformat_minor: 2
+  };
+  notebook.cells.push({
+    cell_type: "markdown",
+    metadata: {},
+    source: [`# Thinking Session: ${session.id}
+`, `
+`, `**Mode**: ${session.mode}  
+`, `**Status**: ${session.status}
+`]
+  });
+  for (const thought of session.thoughts) {
+    notebook.cells.push({
+      cell_type: "markdown",
+      metadata: {},
+      source: [`## Thought ${thought.thoughtNumber}/${session.thoughts.length}
+`, `
+`, `${thought.content}
+`]
+    });
+  }
+  return JSON.stringify(notebook, null, 2);
+}
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);