@vicoa/cli 1.3.11-linux-x64 → 1.3.11-win32-x64

package/bin/_internal/integrations/github/claude-code-action/src/entrypoints/format-turns.ts

@@ -1,465 +1,465 @@
-#!/usr/bin/env bun
-
-import { readFileSync, existsSync } from "fs";
-import { exit } from "process";
-
-export type ToolUse = {
-  type: string;
-  name?: string;
-  input?: Record<string, any>;
-  id?: string;
-};
-
-export type ToolResult = {
-  type: string;
-  tool_use_id?: string;
-  content?: any;
-  is_error?: boolean;
-};
-
-export type ContentItem = {
-  type: string;
-  text?: string;
-  tool_use_id?: string;
-  content?: any;
-  is_error?: boolean;
-  name?: string;
-  input?: Record<string, any>;
-  id?: string;
-};
-
-export type Message = {
-  content: ContentItem[];
-  usage?: {
-    input_tokens?: number;
-    output_tokens?: number;
-  };
-};
-
-export type Turn = {
-  type: string;
-  subtype?: string;
-  message?: Message;
-  tools?: any[];
-  cost_usd?: number;
-  duration_ms?: number;
-  result?: string;
-};
-
-export type GroupedContent = {
-  type: string;
-  tools_count?: number;
-  data?: Turn;
-  text_parts?: string[];
-  tool_calls?: { tool_use: ToolUse; tool_result?: ToolResult }[];
-  usage?: Record<string, number>;
-};
-
-export function detectContentType(content: any): string {
-  const contentStr = String(content).trim();
-
-  // Check for JSON
-  if (contentStr.startsWith("{") && contentStr.endsWith("}")) {
-    try {
-      JSON.parse(contentStr);
-      return "json";
-    } catch {
-      // Fall through
-    }
-  }
-
-  if (contentStr.startsWith("[") && contentStr.endsWith("]")) {
-    try {
-      JSON.parse(contentStr);
-      return "json";
-    } catch {
-      // Fall through
-    }
-  }
-
-  // Check for code-like content
-  const codeKeywords = [
-    "def ",
-    "class ",
-    "import ",
-    "from ",
-    "function ",
-    "const ",
-    "let ",
-    "var ",
-  ];
-  if (codeKeywords.some((keyword) => contentStr.includes(keyword))) {
-    if (
-      contentStr.includes("def ") ||
-      contentStr.includes("import ") ||
-      contentStr.includes("from ")
-    ) {
-      return "python";
-    } else if (
-      ["function ", "const ", "let ", "var ", "=>"].some((js) =>
-        contentStr.includes(js),
-      )
-    ) {
-      return "javascript";
-    } else {
-      return "python"; // default for code
-    }
-  }
-
-  // Check for shell/bash output
-  const shellIndicators = ["ls -", "cd ", "mkdir ", "rm ", "$ ", "# "];
-  if (
-    contentStr.startsWith("/") ||
-    contentStr.includes("Error:") ||
-    contentStr.startsWith("total ") ||
-    shellIndicators.some((indicator) => contentStr.includes(indicator))
-  ) {
-    return "bash";
-  }
-
-  // Check for diff format
-  if (
-    contentStr.startsWith("@@") ||
-    contentStr.includes("+++ ") ||
-    contentStr.includes("--- ")
-  ) {
-    return "diff";
-  }
-
-  // Check for HTML/XML
-  if (contentStr.startsWith("<") && contentStr.endsWith(">")) {
-    return "html";
-  }
-
-  // Check for markdown
-  const mdIndicators = ["# ", "## ", "### ", "- ", "* ", "```"];
-  if (mdIndicators.some((indicator) => contentStr.includes(indicator))) {
-    return "markdown";
-  }
-
-  // Default to plain text
-  return "text";
-}
-
-export function formatResultContent(content: any): string {
-  if (!content) {
-    return "*(No output)*\n\n";
-  }
-
-  let contentStr: string;
-
-  // Check if content is a list with "type": "text" structure
-  try {
-    let parsedContent: any;
-    if (typeof content === "string") {
-      parsedContent = JSON.parse(content);
-    } else {
-      parsedContent = content;
-    }
-
-    if (
-      Array.isArray(parsedContent) &&
-      parsedContent.length > 0 &&
-      typeof parsedContent[0] === "object" &&
-      parsedContent[0]?.type === "text"
-    ) {
-      // Extract the text field from the first item
-      contentStr = parsedContent[0]?.text || "";
-    } else {
-      contentStr = String(content).trim();
-    }
-  } catch {
-    contentStr = String(content).trim();
-  }
-
-  // Truncate very long results
-  if (contentStr.length > 3000) {
-    contentStr = contentStr.substring(0, 2997) + "...";
-  }
-
-  // Detect content type
-  const contentType = detectContentType(contentStr);
-
-  // Handle JSON content specially - pretty print it
-  if (contentType === "json") {
-    try {
-      // Try to parse and pretty print JSON
-      const parsed = JSON.parse(contentStr);
-      contentStr = JSON.stringify(parsed, null, 2);
-    } catch {
-      // Keep original if parsing fails
-    }
-  }
-
-  // Format with appropriate syntax highlighting
-  if (
-    contentType === "text" &&
-    contentStr.length < 100 &&
-    !contentStr.includes("\n")
-  ) {
-    // Short text results don't need code blocks
-    return `**→** ${contentStr}\n\n`;
-  } else {
-    return `**Result:**\n\`\`\`${contentType}\n${contentStr}\n\`\`\`\n\n`;
-  }
-}
-
-export function formatToolWithResult(
-  toolUse: ToolUse,
-  toolResult?: ToolResult,
-): string {
-  const toolName = toolUse.name || "unknown_tool";
-  const toolInput = toolUse.input || {};
-
-  let result = `### 🔧 \`${toolName}\`\n\n`;
-
-  // Add parameters if they exist and are not empty
-  if (Object.keys(toolInput).length > 0) {
-    result += "**Parameters:**\n```json\n";
-    result += JSON.stringify(toolInput, null, 2);
-    result += "\n```\n\n";
-  }
-
-  // Add result if available
-  if (toolResult) {
-    const content = toolResult.content || "";
-    const isError = toolResult.is_error || false;
-
-    if (isError) {
-      result += `❌ **Error:** \`${content}\`\n\n`;
-    } else {
-      result += formatResultContent(content);
-    }
-  }
-
-  return result;
-}
-
-export function groupTurnsNaturally(data: Turn[]): GroupedContent[] {
-  const groupedContent: GroupedContent[] = [];
-  const toolResultsMap = new Map<string, ToolResult>();
-
-  // First pass: collect all tool results by tool_use_id
-  for (const turn of data) {
-    if (turn.type === "user") {
-      const content = turn.message?.content || [];
-      for (const item of content) {
-        if (item.type === "tool_result" && item.tool_use_id) {
-          toolResultsMap.set(item.tool_use_id, {
-            type: item.type,
-            tool_use_id: item.tool_use_id,
-            content: item.content,
-            is_error: item.is_error,
-          });
-        }
-      }
-    }
-  }
-
-  // Second pass: process turns and group naturally
-  for (const turn of data) {
-    const turnType = turn.type || "unknown";
-
-    if (turnType === "system") {
-      const subtype = turn.subtype || "";
-      if (subtype === "init") {
-        const tools = turn.tools || [];
-        groupedContent.push({
-          type: "system_init",
-          tools_count: tools.length,
-        });
-      } else {
-        groupedContent.push({
-          type: "system_other",
-          data: turn,
-        });
-      }
-    } else if (turnType === "assistant") {
-      const message = turn.message || { content: [] };
-      const content = message.content || [];
-      const usage = message.usage || {};
-
-      // Process content items
-      const textParts: string[] = [];
-      const toolCalls: { tool_use: ToolUse; tool_result?: ToolResult }[] = [];
-
-      for (const item of content) {
-        const itemType = item.type || "";
-
-        if (itemType === "text") {
-          textParts.push(item.text || "");
-        } else if (itemType === "tool_use") {
-          const toolUseId = item.id;
-          const toolResult = toolUseId
-            ? toolResultsMap.get(toolUseId)
-            : undefined;
-          toolCalls.push({
-            tool_use: {
-              type: item.type,
-              name: item.name,
-              input: item.input,
-              id: item.id,
-            },
-            tool_result: toolResult,
-          });
-        }
-      }
-
-      if (textParts.length > 0 || toolCalls.length > 0) {
-        groupedContent.push({
-          type: "assistant_action",
-          text_parts: textParts,
-          tool_calls: toolCalls,
-          usage: usage,
-        });
-      }
-    } else if (turnType === "user") {
-      // Handle user messages that aren't tool results
-      const message = turn.message || { content: [] };
-      const content = message.content || [];
-      const textParts: string[] = [];
-
-      for (const item of content) {
-        if (item.type === "text") {
-          textParts.push(item.text || "");
-        }
-      }
-
-      if (textParts.length > 0) {
-        groupedContent.push({
-          type: "user_message",
-          text_parts: textParts,
-        });
-      }
-    } else if (turnType === "result") {
-      groupedContent.push({
-        type: "final_result",
-        data: turn,
-      });
-    }
-  }
-
-  return groupedContent;
-}
-
-export function formatGroupedContent(groupedContent: GroupedContent[]): string {
-  let markdown = "## Claude Code Report\n\n";
-
-  for (const item of groupedContent) {
-    const itemType = item.type;
-
-    if (itemType === "system_init") {
-      markdown += `## 🚀 System Initialization\n\n**Available Tools:** ${item.tools_count} tools loaded\n\n---\n\n`;
-    } else if (itemType === "system_other") {
-      markdown += `## ⚙️ System Message\n\n${JSON.stringify(item.data, null, 2)}\n\n---\n\n`;
-    } else if (itemType === "assistant_action") {
-      // Add text content first (if any) - no header needed
-      for (const text of item.text_parts || []) {
-        if (text.trim()) {
-          markdown += `${text}\n\n`;
-        }
-      }
-
-      // Add tool calls with their results
-      for (const toolCall of item.tool_calls || []) {
-        markdown += formatToolWithResult(
-          toolCall.tool_use,
-          toolCall.tool_result,
-        );
-      }
-
-      // Add usage info if available
-      const usage = item.usage || {};
-      if (Object.keys(usage).length > 0) {
-        const inputTokens = usage.input_tokens || 0;
-        const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
-        const cacheReadTokens = usage.cache_read_input_tokens || 0;
-        const totalInputTokens =
-          inputTokens + cacheCreationTokens + cacheReadTokens;
-        const outputTokens = usage.output_tokens || 0;
-        markdown += `*Token usage: ${totalInputTokens} input, ${outputTokens} output*\n\n`;
-      }
-
-      // Only add separator if this section had content
-      if (
-        (item.text_parts && item.text_parts.length > 0) ||
-        (item.tool_calls && item.tool_calls.length > 0)
-      ) {
-        markdown += "---\n\n";
-      }
-    } else if (itemType === "user_message") {
-      markdown += "## 👤 User\n\n";
-      for (const text of item.text_parts || []) {
-        if (text.trim()) {
-          markdown += `${text}\n\n`;
-        }
-      }
-      markdown += "---\n\n";
-    } else if (itemType === "final_result") {
-      const data = item.data || {};
-      const cost = (data as any).total_cost_usd || (data as any).cost_usd || 0;
-      const duration = (data as any).duration_ms || 0;
-      const resultText = (data as any).result || "";
-
-      markdown += "## ✅ Final Result\n\n";
-      if (resultText) {
-        markdown += `${resultText}\n\n`;
-      }
-      markdown += `**Cost:** $${cost.toFixed(4)} | **Duration:** ${(duration / 1000).toFixed(1)}s\n\n`;
-    }
-  }
-
-  return markdown;
-}
-
-export function formatTurnsFromData(data: Turn[]): string {
-  // Group turns naturally
-  const groupedContent = groupTurnsNaturally(data);
-
-  // Generate markdown
-  const markdown = formatGroupedContent(groupedContent);
-
-  return markdown;
-}
-
-function main(): void {
-  // Get the JSON file path from command line arguments
-  const args = process.argv.slice(2);
-  if (args.length === 0) {
-    console.error("Usage: format-turns.ts <json-file>");
-    exit(1);
-  }
-
-  const jsonFile = args[0];
-  if (!jsonFile) {
-    console.error("Error: No JSON file provided");
-    exit(1);
-  }
-
-  if (!existsSync(jsonFile)) {
-    console.error(`Error: ${jsonFile} not found`);
-    exit(1);
-  }
-
-  try {
-    // Read the JSON file
-    const fileContent = readFileSync(jsonFile, "utf-8");
-    const data: Turn[] = JSON.parse(fileContent);
-
-    // Group turns naturally
-    const groupedContent = groupTurnsNaturally(data);
-
-    // Generate markdown
-    const markdown = formatGroupedContent(groupedContent);
-
-    // Print to stdout (so it can be captured by shell)
-    console.log(markdown);
-  } catch (error) {
-    console.error(`Error processing file: ${error}`);
-    exit(1);
-  }
-}
-
-if (import.meta.main) {
-  main();
-}
+#!/usr/bin/env bun
+
+import { readFileSync, existsSync } from "fs";
+import { exit } from "process";
+
+export type ToolUse = {
+  type: string;
+  name?: string;
+  input?: Record<string, any>;
+  id?: string;
+};
+
+export type ToolResult = {
+  type: string;
+  tool_use_id?: string;
+  content?: any;
+  is_error?: boolean;
+};
+
+export type ContentItem = {
+  type: string;
+  text?: string;
+  tool_use_id?: string;
+  content?: any;
+  is_error?: boolean;
+  name?: string;
+  input?: Record<string, any>;
+  id?: string;
+};
+
+export type Message = {
+  content: ContentItem[];
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+};
+
+export type Turn = {
+  type: string;
+  subtype?: string;
+  message?: Message;
+  tools?: any[];
+  cost_usd?: number;
+  duration_ms?: number;
+  result?: string;
+};
+
+export type GroupedContent = {
+  type: string;
+  tools_count?: number;
+  data?: Turn;
+  text_parts?: string[];
+  tool_calls?: { tool_use: ToolUse; tool_result?: ToolResult }[];
+  usage?: Record<string, number>;
+};
+
+export function detectContentType(content: any): string {
+  const contentStr = String(content).trim();
+
+  // Check for JSON
+  if (contentStr.startsWith("{") && contentStr.endsWith("}")) {
+    try {
+      JSON.parse(contentStr);
+      return "json";
+    } catch {
+      // Fall through
+    }
+  }
+
+  if (contentStr.startsWith("[") && contentStr.endsWith("]")) {
+    try {
+      JSON.parse(contentStr);
+      return "json";
+    } catch {
+      // Fall through
+    }
+  }
+
+  // Check for code-like content
+  const codeKeywords = [
+    "def ",
+    "class ",
+    "import ",
+    "from ",
+    "function ",
+    "const ",
+    "let ",
+    "var ",
+  ];
+  if (codeKeywords.some((keyword) => contentStr.includes(keyword))) {
+    if (
+      contentStr.includes("def ") ||
+      contentStr.includes("import ") ||
+      contentStr.includes("from ")
+    ) {
+      return "python";
+    } else if (
+      ["function ", "const ", "let ", "var ", "=>"].some((js) =>
+        contentStr.includes(js),
+      )
+    ) {
+      return "javascript";
+    } else {
+      return "python"; // default for code
+    }
+  }
+
+  // Check for shell/bash output
+  const shellIndicators = ["ls -", "cd ", "mkdir ", "rm ", "$ ", "# "];
+  if (
+    contentStr.startsWith("/") ||
+    contentStr.includes("Error:") ||
+    contentStr.startsWith("total ") ||
+    shellIndicators.some((indicator) => contentStr.includes(indicator))
+  ) {
+    return "bash";
+  }
+
+  // Check for diff format
+  if (
+    contentStr.startsWith("@@") ||
+    contentStr.includes("+++ ") ||
+    contentStr.includes("--- ")
+  ) {
+    return "diff";
+  }
+
+  // Check for HTML/XML
+  if (contentStr.startsWith("<") && contentStr.endsWith(">")) {
+    return "html";
+  }
+
+  // Check for markdown
+  const mdIndicators = ["# ", "## ", "### ", "- ", "* ", "```"];
+  if (mdIndicators.some((indicator) => contentStr.includes(indicator))) {
+    return "markdown";
+  }
+
+  // Default to plain text
+  return "text";
+}
+
+export function formatResultContent(content: any): string {
+  if (!content) {
+    return "*(No output)*\n\n";
+  }
+
+  let contentStr: string;
+
+  // Check if content is a list with "type": "text" structure
+  try {
+    let parsedContent: any;
+    if (typeof content === "string") {
+      parsedContent = JSON.parse(content);
+    } else {
+      parsedContent = content;
+    }
+
+    if (
+      Array.isArray(parsedContent) &&
+      parsedContent.length > 0 &&
+      typeof parsedContent[0] === "object" &&
+      parsedContent[0]?.type === "text"
+    ) {
+      // Extract the text field from the first item
+      contentStr = parsedContent[0]?.text || "";
+    } else {
+      contentStr = String(content).trim();
+    }
+  } catch {
+    contentStr = String(content).trim();
+  }
+
+  // Truncate very long results
+  if (contentStr.length > 3000) {
+    contentStr = contentStr.substring(0, 2997) + "...";
+  }
+
+  // Detect content type
+  const contentType = detectContentType(contentStr);
+
+  // Handle JSON content specially - pretty print it
+  if (contentType === "json") {
+    try {
+      // Try to parse and pretty print JSON
+      const parsed = JSON.parse(contentStr);
+      contentStr = JSON.stringify(parsed, null, 2);
+    } catch {
+      // Keep original if parsing fails
+    }
+  }
+
+  // Format with appropriate syntax highlighting
+  if (
+    contentType === "text" &&
+    contentStr.length < 100 &&
+    !contentStr.includes("\n")
+  ) {
+    // Short text results don't need code blocks
+    return `**→** ${contentStr}\n\n`;
+  } else {
+    return `**Result:**\n\`\`\`${contentType}\n${contentStr}\n\`\`\`\n\n`;
+  }
+}
+
+export function formatToolWithResult(
+  toolUse: ToolUse,
+  toolResult?: ToolResult,
+): string {
+  const toolName = toolUse.name || "unknown_tool";
+  const toolInput = toolUse.input || {};
+
+  let result = `### 🔧 \`${toolName}\`\n\n`;
+
+  // Add parameters if they exist and are not empty
+  if (Object.keys(toolInput).length > 0) {
+    result += "**Parameters:**\n```json\n";
+    result += JSON.stringify(toolInput, null, 2);
+    result += "\n```\n\n";
+  }
+
+  // Add result if available
+  if (toolResult) {
+    const content = toolResult.content || "";
+    const isError = toolResult.is_error || false;
+
+    if (isError) {
+      result += `❌ **Error:** \`${content}\`\n\n`;
+    } else {
+      result += formatResultContent(content);
+    }
+  }
+
+  return result;
+}
+
+export function groupTurnsNaturally(data: Turn[]): GroupedContent[] {
+  const groupedContent: GroupedContent[] = [];
+  const toolResultsMap = new Map<string, ToolResult>();
+
+  // First pass: collect all tool results by tool_use_id
+  for (const turn of data) {
+    if (turn.type === "user") {
+      const content = turn.message?.content || [];
+      for (const item of content) {
+        if (item.type === "tool_result" && item.tool_use_id) {
+          toolResultsMap.set(item.tool_use_id, {
+            type: item.type,
+            tool_use_id: item.tool_use_id,
+            content: item.content,
+            is_error: item.is_error,
+          });
+        }
+      }
+    }
+  }
+
+  // Second pass: process turns and group naturally
+  for (const turn of data) {
+    const turnType = turn.type || "unknown";
+
+    if (turnType === "system") {
+      const subtype = turn.subtype || "";
+      if (subtype === "init") {
+        const tools = turn.tools || [];
+        groupedContent.push({
+          type: "system_init",
+          tools_count: tools.length,
+        });
+      } else {
+        groupedContent.push({
+          type: "system_other",
+          data: turn,
+        });
+      }
+    } else if (turnType === "assistant") {
+      const message = turn.message || { content: [] };
+      const content = message.content || [];
+      const usage = message.usage || {};
+
+      // Process content items
+      const textParts: string[] = [];
+      const toolCalls: { tool_use: ToolUse; tool_result?: ToolResult }[] = [];
+
+      for (const item of content) {
+        const itemType = item.type || "";
+
+        if (itemType === "text") {
+          textParts.push(item.text || "");
+        } else if (itemType === "tool_use") {
+          const toolUseId = item.id;
+          const toolResult = toolUseId
+            ? toolResultsMap.get(toolUseId)
+            : undefined;
+          toolCalls.push({
+            tool_use: {
+              type: item.type,
+              name: item.name,
+              input: item.input,
+              id: item.id,
+            },
+            tool_result: toolResult,
+          });
+        }
+      }
+
+      if (textParts.length > 0 || toolCalls.length > 0) {
+        groupedContent.push({
+          type: "assistant_action",
+          text_parts: textParts,
+          tool_calls: toolCalls,
+          usage: usage,
+        });
+      }
+    } else if (turnType === "user") {
+      // Handle user messages that aren't tool results
+      const message = turn.message || { content: [] };
+      const content = message.content || [];
+      const textParts: string[] = [];
+
+      for (const item of content) {
+        if (item.type === "text") {
+          textParts.push(item.text || "");
+        }
+      }
+
+      if (textParts.length > 0) {
+        groupedContent.push({
+          type: "user_message",
+          text_parts: textParts,
+        });
+      }
+    } else if (turnType === "result") {
+      groupedContent.push({
+        type: "final_result",
+        data: turn,
+      });
+    }
+  }
+
+  return groupedContent;
+}
+
+export function formatGroupedContent(groupedContent: GroupedContent[]): string {
+  let markdown = "## Claude Code Report\n\n";
+
+  for (const item of groupedContent) {
+    const itemType = item.type;
+
+    if (itemType === "system_init") {
+      markdown += `## 🚀 System Initialization\n\n**Available Tools:** ${item.tools_count} tools loaded\n\n---\n\n`;
+    } else if (itemType === "system_other") {
+      markdown += `## ⚙️ System Message\n\n${JSON.stringify(item.data, null, 2)}\n\n---\n\n`;
+    } else if (itemType === "assistant_action") {
+      // Add text content first (if any) - no header needed
+      for (const text of item.text_parts || []) {
+        if (text.trim()) {
+          markdown += `${text}\n\n`;
+        }
+      }
+
+      // Add tool calls with their results
+      for (const toolCall of item.tool_calls || []) {
+        markdown += formatToolWithResult(
+          toolCall.tool_use,
+          toolCall.tool_result,
+        );
+      }
+
+      // Add usage info if available
+      const usage = item.usage || {};
+      if (Object.keys(usage).length > 0) {
+        const inputTokens = usage.input_tokens || 0;
+        const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+        const cacheReadTokens = usage.cache_read_input_tokens || 0;
+        const totalInputTokens =
+          inputTokens + cacheCreationTokens + cacheReadTokens;
+        const outputTokens = usage.output_tokens || 0;
+        markdown += `*Token usage: ${totalInputTokens} input, ${outputTokens} output*\n\n`;
+      }
+
+      // Only add separator if this section had content
+      if (
+        (item.text_parts && item.text_parts.length > 0) ||
+        (item.tool_calls && item.tool_calls.length > 0)
+      ) {
+        markdown += "---\n\n";
+      }
+    } else if (itemType === "user_message") {
+      markdown += "## 👤 User\n\n";
+      for (const text of item.text_parts || []) {
+        if (text.trim()) {
+          markdown += `${text}\n\n`;
+        }
+      }
+      markdown += "---\n\n";
+    } else if (itemType === "final_result") {
+      const data = item.data || {};
+      const cost = (data as any).total_cost_usd || (data as any).cost_usd || 0;
+      const duration = (data as any).duration_ms || 0;
+      const resultText = (data as any).result || "";
+
+      markdown += "## ✅ Final Result\n\n";
+      if (resultText) {
+        markdown += `${resultText}\n\n`;
+      }
+      markdown += `**Cost:** $${cost.toFixed(4)} | **Duration:** ${(duration / 1000).toFixed(1)}s\n\n`;
+    }
+  }
+
+  return markdown;
+}
+
+export function formatTurnsFromData(data: Turn[]): string {
+  // Group turns naturally
+  const groupedContent = groupTurnsNaturally(data);
+
+  // Generate markdown
+  const markdown = formatGroupedContent(groupedContent);
+
+  return markdown;
+}
+
+function main(): void {
+  // Get the JSON file path from command line arguments
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error("Usage: format-turns.ts <json-file>");
+    exit(1);
+  }
+
+  const jsonFile = args[0];
+  if (!jsonFile) {
+    console.error("Error: No JSON file provided");
+    exit(1);
+  }
+
+  if (!existsSync(jsonFile)) {
+    console.error(`Error: ${jsonFile} not found`);
+    exit(1);
+  }
+
+  try {
+    // Read the JSON file
+    const fileContent = readFileSync(jsonFile, "utf-8");
+    const data: Turn[] = JSON.parse(fileContent);
+
+    // Group turns naturally
+    const groupedContent = groupTurnsNaturally(data);
+
+    // Generate markdown
+    const markdown = formatGroupedContent(groupedContent);
+
+    // Print to stdout (so it can be captured by shell)
+    console.log(markdown);
+  } catch (error) {
+    console.error(`Error processing file: ${error}`);
+    exit(1);
+  }
+}
+
+if (import.meta.main) {
+  main();
+}