chatgpt-to-markdown 1.5.5 → 1.7.0

package/README.md

@@ -18,6 +18,26 @@ npx chatgpt-to-markdown path/to/your/conversations.json
 
 This will generate one Markdown file for each chat same directory as the conversations JSON file. The file name will be the chat title, with invalid filename characters replaced by spaces.
 
+## Thinking Time Analysis
+
+Analyze thinking time statistics from your ChatGPT conversations:
+
+```bash
+npx -p chatgpt-to-markdown thinktime path/to/your/conversations.json
+```
+
+This will analyze all conversations and show statistics about thinking/reasoning time, including:
+
+- Total conversations with thinking
+- Total thinking time and blocks
+- Distribution of thinking times
+- Top conversations by thinking time
+- Top individual thinking blocks
+
+Optional flag:
+
+- `--save-details`: Save detailed results to `thinking_analysis_results_node.json`
+
 ## Example
 
 Here's an example of the Markdown output for a chat with the title `Medium-Style Table CSS`:
@@ -97,6 +117,8 @@ git push --follow-tags
 
 ## Release notes
 
+- 1.7.0: 29 Jun 2025. Add thinktime analysis tool as npx executable. Analyze thinking/reasoning time statistics from ChatGPT conversations.
+- 1.6.0: 18 Jul 2025. Handle `thoughts`, `reasoning_recap`, `sonic_webpage`. Include projects
 - 1.5.5: 02 Nov 2024. Add conversation link. Use conversation ID as fallback title if title is empty.
 - 1.5.4: 02 Nov 2024. Skip `user_editable_context` to avoid polluting Markdown with custom instructions
 - 1.5.3: 05 Aug 2024. Show text from multimodal prompts

package/index.js

@@ -38,6 +38,74 @@ function indent(str) {
     .join("");
 }
 
+function blockquote(str) {
+  return str
+    .split("\n")
+    .map((v) => (v ? `> ${v}` : ">"))
+    .join("\n");
+}
+
+function nodeToMarkdown(node) {
+  try {
+    const content = node.message?.content;
+    if (!content) return "";
+    let body;
+    switch (content.content_type) {
+      case "text":
+        body = content.parts.join("\n");
+        break;
+      case "code":
+        body = "```" + content.language.replace("unknown", "") + "\n" + content.text + "\n```";
+        break;
+      case "execution_output":
+        body = "```\n" + content.text + "\n```";
+        break;
+      case "multimodal_text":
+        body = content.parts
+          .map((part) =>
+            typeof part == "string"
+              ? `${part}\n\n`
+              : part.content_type === "image_asset_pointer"
+                ? `Image (${part.width}x${part.height}): ${part?.metadata?.dalle?.prompt ?? ""}\n\n`
+                : `${part.content_type}\n\n`,
+          )
+          .join("");
+        break;
+      case "tether_browsing_display":
+        body = "```\n" + (content.summary ? `${content.summary}\n` : "") + content.result + "\n```";
+        break;
+      case "tether_quote":
+        body = blockquote(`${content.title} (${content.url})\n\n${content.text}`);
+        break;
+      case "system_error":
+        body = `${content.name}\n\n${content.text}\n\n`;
+        break;
+      case "user_editable_context":
+        body = "";
+        break;
+      case "thoughts":
+        body = content.thoughts.map((t) => `##### ${t.summary}\n\n${t.content}\n`).join("\n");
+        break;
+      case "reasoning_recap":
+        body = blockquote(content.content);
+        break;
+      case "sonic_webpage":
+        body = "```\n" + `${content.title} (${content.url})\n\n${content.text}` + "\n```";
+        break;
+      default:
+        body = String(content);
+    }
+    if (!body.trim()) return "";
+    const author = node.message.author;
+    if (author.role == "user") body = indent(body);
+    if (author.role == "tool" && !body.startsWith("```") && !body.endsWith("```")) body = indent(body);
+    return `## ${author.role}${author.name ? ` (${author.name})` : ""}\n\n${body}\n\n`;
+  } catch (err) {
+    err.message += `\nNode: ${JSON.stringify(node)}`;
+    throw err;
+  }
+}
+
 const dateFormat = new Intl.DateTimeFormat("en-US", {
   day: "numeric",
   month: "short",
@@ -73,65 +141,14 @@ async function chatgptToMarkdown(json, sourceDir, { dateFormat } = { dateFormat:
     const fileName = `${sanitizedTitle}.md`;
     const filePath = path.join(sourceDir, fileName);
     const title = `# ${wrapHtmlTagsInBackticks(conversation.title)}\n`;
-    const metadata = [
+    const lines = [
       `- Created: ${dateFormat(new Date(conversation.create_time * 1000))}\n`,
       `- Updated: ${dateFormat(new Date(conversation.update_time * 1000))}\n`,
       `- Link: https://chatgpt.com/c/${conversation.conversation_id}\n`,
-    ].join("");
-    const messages = Object.values(conversation.mapping)
-      .map((node) => {
-        let content = node.message?.content;
-        if (!content) return "";
-        // Format the body based on the content type
-        let body;
-        switch (content.content_type) {
-          case "text":
-            body = content.parts.join("\n");
-            break;
-          case "code":
-            body = "```" + content.language.replace("unknown", "") + "\n" + content.text + "\n```";
-            break;
-          case "execution_output":
-            body = "```\n" + content.text + "\n```";
-            break;
-          case "multimodal_text":
-            body = content.parts
-              .map((part) =>
-                typeof part == "string"
-                  ? `${part}\n\n`
-                  : part.content_type === "image_asset_pointer"
-                    ? `Image (${part.width}x${part.height}): ${part?.metadata?.dalle?.prompt ?? ""}\n\n`
-                    : `${part.content_type}\n\n`,
-              )
-              .join("");
-            break;
-          case "tether_browsing_display":
-            body = "```\n" + (content.summary ? `${content.summary}\n` : "") + content.result + "\n```";
-            break;
-          case "tether_quote":
-            body = "```\n" + `${content.title} (${content.url})\n\n${content.text}` + "\n```";
-            break;
-          case "system_error":
-            body = `${content.name}\n\n${content.text}\n\n`;
-            break;
-          case "user_editable_context":
-            // We don't want to pollute all Markdown with custom instuctions
-            // in content.user_instructions. So skip it
-            body = "";
-            break;
-          default:
-            body = content;
-            break;
-        }
-        // Ignore empty content
-        if (!body.trim()) return "";
-        // Indent user / tool messages. The sometimes contain code and whitespaces are relevant
-        const author = node.message.author;
-        if (author.role == "user") body = indent(body);
-        if (author.role == "tool" && !body.startsWith("```") && !body.endsWith("```")) body = indent(body);
-        return `## ${author.role}${author.name ? ` (${author.name})` : ""}\n\n${body}\n\n`;
-      })
-      .join("");
+    ];
+    if (conversation.gizmo_id) lines.push(`- Project: https://chatgpt.com/g/${conversation.gizmo_id}/project\n`);
+    const metadata = lines.join("");
+    const messages = Object.values(conversation.mapping).map(nodeToMarkdown).join("");
     const markdownContent = `${title}\n${metadata}\n${messages}`;
     await fs.writeFile(filePath, markdownContent, "utf8");
     await fs.utimes(filePath, conversation.update_time, conversation.create_time);

package/package.json

@@ -1,15 +1,22 @@
 {
   "name": "chatgpt-to-markdown",
-  "version": "1.5.5",
+  "version": "1.7.0",
   "description": "Convert ChatGPT exported conversations.json to Markdown",
   "main": "index.js",
   "type": "module",
+  "files": [
+    "cli.js",
+    "index.js",
+    "thinktime.js",
+    "README.md"
+  ],
   "bin": {
-    "chatgpt-to-markdown": "cli.js"
+    "chatgpt-to-markdown": "cli.js",
+    "thinktime": "thinktime.js"
   },
   "scripts": {
-    "prepublishOnly": "npx prettier --write *.js *.md package.json && npm test",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    "prepublishOnly": "npx -y prettier@3.5 --write *.js *.md package.json && npm test",
+    "test": "npx -y vitest@3 run --globals"
   },
   "keywords": [
     "chatgpt",
@@ -20,9 +27,5 @@
   "license": "MIT",
   "prettier": {
     "printWidth": 120
-  },
-  "devDependencies": {
-    "jest": "^29.7.0",
-    "prettier": "^3.2.5"
   }
 }

package/thinktime.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+/**
+ * Thinking Time Analysis for ChatGPT Conversations (Node.js version)
+ *
+ * This program analyzes a conversations.json file to calculate thinking time for each conversation.
+ *
+ * APPROACH:
+ * 1. The JSON contains conversations with a "mapping" field containing message nodes
+ * 2. Thinking is identified by metadata field "reasoning_status" with values:
+ *    - "is_reasoning": indicates the model is currently thinking/reasoning
+ *    - "reasoning_ended": indicates thinking has completed
+ * 3. Time measurement uses "finished_duration_sec" field in metadata, which represents
+ *    actual generation time (not wall time including user wait time)
+ * 4. Each conversation is analyzed to find thinking blocks and sum their durations
+ *
+ * KEY FINDINGS FROM DATA ANALYSIS:
+ * - reasoning_status="is_reasoning" marks start of thinking
+ * - reasoning_status="reasoning_ended" marks end with "finished_duration_sec"
+ * - finished_duration_sec contains the actual model generation time in seconds
+ * - Not all conversations have thinking - many are regular chat without reasoning
+ */
+
+import { promises as fs } from "fs";
+
+function findPrecedingUserMessage(mapping, targetNodeId) {
+  /**
+   * Find the user message that precedes a thinking block.
+   */
+  const targetNode = mapping[targetNodeId] || {};
+  const parentId = targetNode.parent;
+
+  // Traverse up the conversation tree to find the last user message
+  const visited = new Set();
+  let currentId = parentId;
+
+  while (currentId && !visited.has(currentId)) {
+    visited.add(currentId);
+    const currentNode = mapping[currentId] || {};
+    const message = currentNode.message || {};
+
+    if (message) {
+      const author = message.author || {};
+      if (author.role === "user") {
+        // Found user message, extract content
+        const content = message.content || {};
+        const parts = content.parts || [];
+        if (parts.length > 0 && typeof parts[0] === "string") {
+          const text = parts[0].replace(/\s+/g, " ").trim();
+          return text.length > 200 ? text.substring(0, 200) + "..." : text;
+        }
+      }
+    }
+
+    // Move to parent
+    currentId = currentNode.parent;
+  }
+
+  return "No preceding user message found";
+}
+
+function analyzeConversationThinking(conversation) {
+  /**
+   * Analyze a single conversation for thinking time.
+   *
+   * Returns:
+   * - totalThinkingTime: Total seconds spent thinking
+   * - thinkingBlocks: Number of separate thinking sessions
+   * - thinkingDetails: Array of thinking block details with preceding user messages
+   */
+  const mapping = conversation.mapping || {};
+  let totalThinkingTime = 0.0;
+  let thinkingBlocks = 0;
+  const thinkingDetails = [];
+
+  for (const [nodeId, node] of Object.entries(mapping)) {
+    const message = node.message || {};
+    if (!message) continue;
+
+    const metadata = message.metadata || {};
+    const reasoningStatus = metadata.reasoning_status;
+
+    if (reasoningStatus === "reasoning_ended") {
+      // This node marks the end of a thinking block
+      const duration = metadata.finished_duration_sec || 0;
+      if (duration && duration > 0) {
+        totalThinkingTime += duration;
+        thinkingBlocks++;
+
+        // Find the user message that preceded this thinking block
+        const precedingMessage = findPrecedingUserMessage(mapping, nodeId);
+
+        thinkingDetails.push({
+          nodeId: nodeId,
+          durationSec: duration,
+          createTime: message.create_time,
+          precedingUserMessage: precedingMessage,
+          conversationId: conversation.conversation_id || "unknown",
+          conversationTitle: conversation.title || "Untitled",
+        });
+      }
+    }
+  }
+
+  return { totalThinkingTime, thinkingBlocks, thinkingDetails };
+}
+
+async function analyzeAllConversations(filename) {
+  /**
+   * Analyze all conversations in the JSON file.
+   *
+   * Returns object with analysis results.
+   */
+  console.log(`Loading ${filename}...`);
+  const data = JSON.parse(await fs.readFile(filename, "utf8"));
+
+  console.log(`Found ${data.length} conversations`);
+
+  const results = {
+    totalConversations: data.length,
+    conversationsWithThinking: 0,
+    totalThinkingTime: 0.0,
+    totalThinkingBlocks: 0,
+    conversationDetails: [],
+    thinkingDistribution: {
+      "0-5 seconds": 0,
+      "5-15 seconds": 0,
+      "15-30 seconds": 0,
+      "30-60 seconds": 0,
+      "60+ seconds": 0,
+    },
+    allThinkingBlocks: [], // New: collect all individual thinking blocks
+  };
+
+  for (let i = 0; i < data.length; i++) {
+    if (i % 500 === 0) {
+      console.log(`Processing conversation ${i}...`);
+    }
+
+    const conversation = data[i];
+    const convId = conversation.conversation_id || `unknown_${i}`;
+    const title = conversation.title || "Untitled";
+
+    const { totalThinkingTime, thinkingBlocks, thinkingDetails } = analyzeConversationThinking(conversation);
+
+    if (totalThinkingTime > 0) {
+      results.conversationsWithThinking++;
+      results.totalThinkingTime += totalThinkingTime;
+      results.totalThinkingBlocks += thinkingBlocks;
+
+      // Add all individual thinking blocks to global list
+      results.allThinkingBlocks.push(...thinkingDetails);
+
+      // Categorize thinking time for distribution analysis
+      if (totalThinkingTime < 5) {
+        results.thinkingDistribution["0-5 seconds"]++;
+      } else if (totalThinkingTime < 15) {
+        results.thinkingDistribution["5-15 seconds"]++;
+      } else if (totalThinkingTime < 30) {
+        results.thinkingDistribution["15-30 seconds"]++;
+      } else if (totalThinkingTime < 60) {
+        results.thinkingDistribution["30-60 seconds"]++;
+      } else {
+        results.thinkingDistribution["60+ seconds"]++;
+      }
+
+      results.conversationDetails.push({
+        conversationId: convId,
+        title: title,
+        thinkingTimeSec: totalThinkingTime,
+        thinkingBlocks: thinkingBlocks,
+        thinkingDetails: thinkingDetails,
+      });
+    }
+  }
+
+  return results;
+}
+
+function printResults(results) {
+  /**
+   * Print analysis results in a readable format.
+   */
+  console.log("\n" + "=".repeat(60));
+  console.log("THINKING TIME ANALYSIS RESULTS");
+  console.log("=".repeat(60));
+
+  const totalConvs = results.totalConversations;
+  const thinkingConvs = results.conversationsWithThinking;
+
+  console.log(`Total conversations: ${totalConvs.toLocaleString()}`);
+  console.log(
+    `Conversations with thinking: ${thinkingConvs.toLocaleString()} (${((thinkingConvs / totalConvs) * 100).toFixed(1)}%)`,
+  );
+  console.log(`Conversations without thinking: ${(totalConvs - thinkingConvs).toLocaleString()}`);
+
+  if (thinkingConvs > 0) {
+    console.log(`\nTHINKING TIME STATISTICS:`);
+    console.log(
+      `Total thinking time: ${results.totalThinkingTime.toFixed(1)} seconds (${(results.totalThinkingTime / 60).toFixed(1)} minutes)`,
+    );
+    console.log(`Total thinking blocks: ${results.totalThinkingBlocks.toLocaleString()}`);
+    console.log(
+      `Average thinking time per conversation: ${(results.totalThinkingTime / thinkingConvs).toFixed(1)} seconds`,
+    );
+    console.log(
+      `Average thinking blocks per conversation: ${(results.totalThinkingBlocks / thinkingConvs).toFixed(1)}`,
+    );
+
+    console.log(`\nTHINKING TIME DISTRIBUTION:`);
+    for (const [category, count] of Object.entries(results.thinkingDistribution)) {
+      const percentage = ((count / thinkingConvs) * 100).toFixed(1);
+      console.log(`  ${category}: ${count.toLocaleString()} conversations (${percentage}%)`);
+    }
+
+    console.log(`\nTOP 10 CONVERSATIONS BY THINKING TIME:`);
+    const sortedConvs = results.conversationDetails.sort((a, b) => b.thinkingTimeSec - a.thinkingTimeSec).slice(0, 10);
+
+    sortedConvs.forEach((conv, i) => {
+      const title = conv.title.length > 50 ? conv.title.substring(0, 50) + "..." : conv.title;
+      console.log(
+        `  ${(i + 1).toString().padStart(2)}. ${conv.thinkingTimeSec.toFixed(1).padStart(6)}s (${conv.thinkingBlocks} blocks) - ${title}`,
+      );
+    });
+
+    console.log(`\nTOP 10 INDIVIDUAL THINKING BLOCKS:`);
+    const sortedBlocks = results.allThinkingBlocks.sort((a, b) => b.durationSec - a.durationSec).slice(0, 10);
+
+    sortedBlocks.forEach((block, i) => {
+      const title =
+        block.conversationTitle.length > 30
+          ? block.conversationTitle.substring(0, 30) + "..."
+          : block.conversationTitle;
+      const userMsg =
+        block.precedingUserMessage.length > 80
+          ? block.precedingUserMessage.substring(0, 80) + "..."
+          : block.precedingUserMessage;
+      console.log(`  ${(i + 1).toString().padStart(2)}. ${block.durationSec.toFixed(1).padStart(6)}s - ${title}`);
+      console.log(`      User: ${userMsg}`);
+      console.log();
+    });
+  }
+}
+
+async function main() {
+  const filename = process.argv[2] || "conversations.json";
+
+  try {
+    const startTime = process.hrtime.bigint();
+    const results = await analyzeAllConversations(filename);
+    const endTime = process.hrtime.bigint();
+
+    printResults(results);
+
+    // Print execution time
+    const executionTimeMs = Number(endTime - startTime) / 1000000;
+    console.log(`\nExecution time: ${(executionTimeMs / 1000).toFixed(2)} seconds`);
+
+    // Optionally save detailed results to JSON
+    if (process.argv[3] === "--save-details") {
+      const outputFile = "thinking_analysis_results_node.json";
+      await fs.writeFile(outputFile, JSON.stringify(results, null, 2));
+      console.log(`\nDetailed results saved to ${outputFile}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      console.error(`Error: File '${filename}' not found`);
+      console.error("Usage: node thinking_time.js [conversations.json] [--save-details]");
+      process.exit(1);
+    } else if (error instanceof SyntaxError) {
+      console.error(`Error: Invalid JSON in file '${filename}': ${error.message}`);
+      process.exit(1);
+    } else {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}

package/index.test.js

@@ -1,380 +0,0 @@
-// index.test.js
-
-import { promises as fs } from "fs";
-import path from "path";
-import os from "os";
-import { default as chatgptToMarkdown, formatDate } from "./index";
-
-describe("chatgptToMarkdown", () => {
-  let tempDir;
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "chatgptToMarkdown-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  it("should write a markdown file for each conversation", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        conversation_id: "abc123",
-        mapping: {
-          0: {
-            message: {
-              author: { role: "user", name: "John" },
-              content: { content_type: "text", parts: ["Hello"] },
-            },
-          },
-        },
-      },
-    ];
-
-    await chatgptToMarkdown(json, tempDir);
-
-    const filePath = path.join(tempDir, "Test Conversation.md");
-    const fileContent = await fs.readFile(filePath, "utf8");
-
-    expect(fileContent).toBe(`# Test Conversation
-
-- Created: ${formatDate(1630454400 * 1000)}
-- Updated: ${formatDate(1630458000 * 1000)}
-- Link: https://chatgpt.com/c/abc123
-
-## user (John)
-
-    Hello
-
-
-`);
-  });
-
-  it("should handle titles with HTML tags", async () => {
-    const json = [
-      {
-        title: "<h1>Test Conversation</h1>",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {},
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "h1 Test Conversation h1.md"), "utf8");
-    expect(fileContent).toContain("# `<h1>`Test Conversation`</h1>`\n");
-  });
-
-  it("should sanitize titles with invalid filename characters", async () => {
-    const json = [
-      {
-        title: ":/In\\<>*valid|?",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {},
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    // Check that the file exists with the sanitized title
-    await expect(fs.access(path.join(tempDir, "In valid.md"))).resolves.not.toThrow();
-  });
-
-  it("should handle custom date format functions", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {},
-      },
-    ];
-    const customDateFormat = (date) => date.toISOString();
-    await chatgptToMarkdown(json, tempDir, { dateFormat: customDateFormat });
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("- Created: 2021-09-01T00:00:00.000Z\n");
-  });
-
-  it("should ignore messages with no content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              /* no content property */
-            },
-          },
-        },
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).not.toContain("## user (John)");
-  });
-
-  it("should ignore messages with empty content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: { message: { content: { content_type: "text", parts: [] } } },
-        },
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).not.toContain("## user (John)");
-  });
-
-  it("should handle tether_browsing_display content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "tool", name: "browser" },
-              content: { content_type: "tether_browsing_display", result: "L0: x" },
-            },
-          },
-        },
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("```\nL0: x\n```");
-  });
-
-  it("should handle tether_quote content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "tool", name: "browser" },
-              content: { content_type: "tether_quote", url: "x.com", domain: "x.com", title: "T", text: "X" },
-            },
-          },
-        },
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("```\nT (x.com)\n\nX\n```");
-  });
-
-  it("should handle multimodal_text content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "tool", name: "dalle.text2im" },
-              content: {
-                content_type: "multimodal_text",
-                parts: [
-                  {
-                    content_type: "image_asset_pointer",
-                    width: 1024,
-                    height: 1024,
-                    metadata: { dalle: { prompt: "Photo" } },
-                  },
-                  { content_type: "image_asset_pointer", width: 1024, height: 1024 },
-                  { content_type: "some_other_type" },
-                ],
-              },
-            },
-          },
-        },
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("Image (1024x1024): Photo\n");
-    expect(fileContent).toContain("some_other_type\n");
-  });
-
-  it("should indent messages with tool role that contain ``` fenced code blocks", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "tool" },
-              content: { content_type: "code", language: "javascript", text: 'console.log("Hello, world!");' },
-            },
-          },
-        },
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain('```javascript\nconsole.log("Hello, world!");\n```\n');
-  });
-
-  it("should skip user_editable_context content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "user" },
-              content: {
-                content_type: "user_editable_context",
-                user_profile: "test profile",
-                user_instructions: "test instructions",
-              },
-            },
-          },
-        },
-      },
-    ];
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).not.toContain("test profile");
-    expect(fileContent).not.toContain("test instructions");
-  });
-
-  it("should handle system_error content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "system" },
-              content: {
-                content_type: "system_error",
-                name: "Error Name",
-                text: "Error details",
-              },
-            },
-          },
-        },
-      },
-    ];
-
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("Error Name\n\nError details\n\n");
-  });
-
-  it("should handle execution_output content", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "assistant" },
-              content: {
-                content_type: "execution_output",
-                text: "Program output",
-              },
-            },
-          },
-        },
-      },
-    ];
-
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("```\nProgram output\n```");
-  });
-
-  it("should handle code content with unknown language", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "assistant" },
-              content: {
-                content_type: "code",
-                language: "unknown",
-                text: "some code",
-              },
-            },
-          },
-        },
-      },
-    ];
-
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("```\nsome code\n```");
-  });
-
-  it("should handle tether_browsing_display with summary", async () => {
-    const json = [
-      {
-        title: "Test Conversation",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {
-          0: {
-            message: {
-              author: { role: "tool" },
-              content: {
-                content_type: "tether_browsing_display",
-                summary: "Page Summary",
-                result: "Search Result",
-              },
-            },
-          },
-        },
-      },
-    ];
-
-    await chatgptToMarkdown(json, tempDir);
-    const fileContent = await fs.readFile(path.join(tempDir, "Test Conversation.md"), "utf8");
-    expect(fileContent).toContain("```\nPage Summary\nSearch Result\n```");
-  });
-
-  it("should throw TypeError for invalid arguments", async () => {
-    await expect(chatgptToMarkdown("not an array", tempDir)).rejects.toThrow(TypeError);
-    await expect(chatgptToMarkdown([], 123)).rejects.toThrow(TypeError);
-  });
-
-  it("should use conversation_id as filename when sanitized title is empty", async () => {
-    const json = [
-      {
-        title: "?????", // Will be sanitized to empty string
-        conversation_id: "abc123",
-        create_time: 1630454400,
-        update_time: 1630458000,
-        mapping: {},
-      },
-    ];
-
-    await chatgptToMarkdown(json, tempDir);
-    await expect(fs.access(path.join(tempDir, "abc123.md"))).resolves.not.toThrow();
-  });
-});