@patze/code-cli 0.24.0 → 0.41.0

package/opentui/src/App.tsx

@@ -12,7 +12,6 @@ import {
 } from "@opentui/react"
 import { createElement, useCallback, useEffect, useMemo, useRef, useState } from "react"
 
-import { parseTranscriptLine } from "./line-parse.js"
 import { importPatzeDist } from "./patze-dist.js"
 import {
   buildTranscriptLines,
@@ -23,7 +22,7 @@ import {
 } from "./transcript-render.js"
 import { classifyPlainOutput, createTranscriptSink, inferErrorKind } from "./tui-sink.js"
 import { upsertTranscriptEntry } from "../../dist/cli/interactive/transcript-upsert.js"
-import { applyAgentEvent } from "../../dist/cli/interactive/agent-event-feed.js"
+import { applyOpenTuiAgentEvent } from "../../dist/cli/interactive/opentui-agent-event.js"
 import type { AgentEvent } from "../../dist/cli/interactive/agent-events.js"
 
 extend({ "tui-input": InputRenderable })
@@ -58,6 +57,10 @@ type InteractiveController = {
   session: {
     getModelOverride: () => string | null
     setModelOverride: (value: string | null) => void
+    getModelThinking: () => boolean | null
+    setModelThinking: (value: boolean | null) => void
+    getModelFast: () => boolean | null
+    setModelFast: (value: boolean | null) => void
     getExecutionMode: () => "local" | "cloud"
     snapshot: () => Array<{ input: string; lines: string[] }>
   }
@@ -73,7 +76,7 @@ type InteractiveController = {
       useActivitySpinner?: boolean
       onAgentEvent?: (event: AgentEvent) => void
     }
-  ) => Promise<{ exitShell: boolean; exitCode: number; streamed?: boolean }>
+  ) => Promise<{ exitShell: boolean; exitCode: number; streamed?: boolean; clearVisibleTranscript?: boolean }>
 }
 
 function parseCwdArg(): string {
@@ -107,10 +110,15 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
   const [scrollOffset, setScrollOffset] = useState(0)
   const [transcript, setTranscript] = useState<TranscriptEntry[]>([])
   const [currentModel, setCurrentModel] = useState("composer-2.5-fast")
+  const [modelThinking, setModelThinking] = useState<boolean | null>(null)
+  const [modelFast, setModelFast] = useState<boolean | null>(null)
   const [executionMode, setExecutionMode] = useState<"local" | "cloud">("local")
   const [executionTarget, setExecutionTarget] = useState<string | null>(null)
   const [supportedModels, setSupportedModels] = useState<string[]>([])
   const [slashMenuReady, setSlashMenuReady] = useState(false)
+  const [startupHeader, setStartupHeader] = useState<string[]>([])
+  const [composerPlaceholder, setComposerPlaceholder] = useState("Describe a task… · / for commands")
+  const [emptySessionHints, setEmptySessionHints] = useState<string[]>([])
 
   const followTranscript = useCallback(() => {
     if (scrollPinnedRef.current) {
@@ -194,6 +202,14 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
     streamingIdRef.current = null
   }, [])
 
+  const openTuiStreamHandlers = useMemo(
+    () => ({
+      onAssistantDelta: upsertStreaming,
+      onClearAssistantStream: clearStreaming,
+    }),
+    [clearStreaming, upsertStreaming]
+  )
+
   const refreshStatusMeta = useCallback(async () => {
     const controller = controllerRef.current
     if (!controller) {
@@ -213,7 +229,26 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
       })
     )
     setExecutionMode(controller.session.getExecutionMode())
-    setSupportedModels([...models.PATZE_SUPPORTED_MODELS])
+    setModelThinking(controller.session.getModelThinking())
+    setModelFast(controller.session.getModelFast())
+
+    let modelIds = [...models.PATZE_SUPPORTED_MODELS]
+    const apiKey = process.env.CURSOR_API_KEY?.trim()
+    if (apiKey) {
+      try {
+        const { Cursor } = await import("@cursor/sdk")
+        const listed = await Cursor.models.list({ apiKey })
+        const ids = listed
+          .map((item) => String(item.id ?? "").trim())
+          .filter(Boolean)
+        if (ids.length > 0) {
+          modelIds = ids
+        }
+      } catch {
+        // keep bundled fallback list
+      }
+    }
+    setSupportedModels(modelIds)
 
     const cloudGit = await importPatzeDist<
       typeof import("../../dist/cli/interactive/cloud-git.js")
@@ -226,6 +261,16 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
     } else {
       setExecutionTarget(null)
     }
+
+    const authGate = await importPatzeDist<
+      typeof import("../../dist/cli/interactive/auth-gate.js")
+    >("cli/interactive/auth-gate.js")
+    setComposerPlaceholder(authGate.resolveComposerPlaceholder(controller.cwd))
+
+    const sessionHints = await importPatzeDist<
+      typeof import("../../dist/cli/interactive/session-hints.js")
+    >("cli/interactive/session-hints.js")
+    setEmptySessionHints(sessionHints.buildEmptySessionHints(controller.cwd))
   }, [])
 
   useEffect(() => {
@@ -254,10 +299,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
         const controller = (await sessionMod.prepareInteractiveController({
           cwd,
           interactive: true,
-          streamPartials: true,
-          onPartial: (chunk: string) => {
-            upsertStreaming(chunk)
-          },
+          streamPartials: false,
         })) as InteractiveController
 
         if (cancelled) {
@@ -265,21 +307,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
         }
 
         controllerRef.current = controller
-
-        const headerEntries = controller.renderHeaderLines().flatMap((line) => {
-          const parsed = parseTranscriptLine(line)
-          if (!parsed || parsed.continuation) {
-            return []
-          }
-          return [
-            {
-              id: nextId(),
-              kind: "meta" as const,
-              label: parsed.label || "info",
-              text: parsed.text || line,
-            },
-          ]
-        })
+        setStartupHeader(controller.renderHeaderLines())
 
         const restored: TranscriptEntry[] = []
         for (const turn of controller.session.snapshot()) {
@@ -294,7 +322,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
           }
         }
 
-        setTranscript([...headerEntries, ...restored])
+        setTranscript(restored)
         await refreshStatusMeta()
         setReady(true)
       } catch (error) {
@@ -306,7 +334,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
     return () => {
       cancelled = true
     }
-  }, [cwd, nextId, refreshStatusMeta, upsertStreaming])
+  }, [cwd, nextId, refreshStatusMeta])
 
   const exitApp = useCallback(() => {
     controllerRef.current?.persistSession()
@@ -320,7 +348,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
         return
       }
 
-      const value = rawLine.trim()
+      const value = trimComposerPrompt(rawLine)
       if (!value) {
         return
       }
@@ -351,16 +379,22 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
         const result = await controller.processLine(value, sink, {
           signal: abort.signal,
           onActivity: setActivityLabel,
-          useActivitySpinner: false,
+          useActivitySpinner: true,
           onAgentEvent: (event) => {
             setActivityLabel(null)
-            setTranscript((items) => applyAgentEvent(items, event, turnAssistantId))
+            setTranscript((items) =>
+              applyOpenTuiAgentEvent(items, event, turnAssistantId, openTuiStreamHandlers)
+            )
             followTranscript()
           },
         })
         if (result.streamed) {
           clearStreaming()
         }
+        if (result.clearVisibleTranscript) {
+          setTranscript([])
+          markScrollPinned()
+        }
         await refreshStatusMeta()
         if (result.exitShell) {
           exitApp()
@@ -380,6 +414,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
       followTranscript,
       markScrollPinned,
       nextId,
+      openTuiStreamHandlers,
       refreshStatusMeta,
       upsertTranscriptLine,
       upsertStreaming,
@@ -391,6 +426,23 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
     setMode("model")
   }, [])
 
+  const toggleModelPreference = useCallback((kind: "thinking" | "fast") => {
+    const controller = controllerRef.current
+    if (!controller) {
+      return
+    }
+    if (kind === "thinking") {
+      const next = controller.session.getModelThinking() === true ? null : true
+      controller.session.setModelThinking(next)
+      setModelThinking(next)
+    } else {
+      const next = controller.session.getModelFast() === true ? null : true
+      controller.session.setModelFast(next)
+      setModelFast(next)
+    }
+    controller.persistSession()
+  }, [])
+
   const runCommand = useCallback(
     async (rawCommand: string) => {
       const trimmed = rawCommand.trim()
@@ -407,8 +459,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
 
       switch (name?.toLowerCase()) {
         case "help":
-          setInput("/")
-          setMode("command")
+          await submitToController("/help")
           return
         case "model":
           if (!args.trim()) {
@@ -431,7 +482,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
 
   const submitInput = useCallback(
     (value: string) => {
-      const prompt = value.trim()
+      const prompt = trimComposerPrompt(value)
       setInput("")
 
       if (!prompt || busy) {
@@ -473,41 +524,26 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
   const modelSelectRows = Math.min(8, Math.max(3, rows - 10))
   const commandPanelRows = 2 + commandSelectRows
   const modelPanelRows = 3 + modelSelectRows
+  const headerRows = Math.max(1, startupHeader.length)
+  const composerChromeRows = 5
+  const bottomHintRows = 1
 
   const transcriptViewportRows = Math.max(
     4,
-    rows - (mode === "model" ? modelPanelRows + 4 : mode === "command" ? commandPanelRows + 4 : 6)
+    rows -
+      headerRows -
+      bottomHintRows -
+      (mode === "model"
+        ? modelPanelRows + 2
+        : mode === "command"
+          ? commandPanelRows + 2
+          : composerChromeRows)
   )
 
-  const scrollableEntries = useMemo(
-    () => [
-      { id: "status-cwd", kind: "meta" as const, label: "cwd", text: cwd },
-      {
-        id: "status-mode",
-        kind: "meta" as const,
-        label: "mode",
-        text: executionMode,
-      },
-      ...(executionTarget
-        ? [
-            {
-              id: "status-target",
-              kind: "meta" as const,
-              label: "target",
-              text: executionTarget,
-            },
-          ]
-        : []),
-      {
-        id: "status-model",
-        kind: "meta" as const,
-        label: "model",
-        text: currentModel,
-      },
-      ...transcript,
-    ],
-    [cwd, currentModel, executionMode, executionTarget, transcript]
-  )
+  const composerModelLabel = `${currentModel}${modelThinking ? " · thinking" : ""}${modelFast ? " · fast" : ""}`
+  const composerPathLabel = shortenComposerPath(cwd)
+
+  const scrollableEntries = useMemo(() => transcript, [transcript])
 
   const transcriptLines = useMemo(
     () => buildTranscriptLines(scrollableEntries, columns),
@@ -548,6 +584,26 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
       }))
   }, [currentModel, modelSearch, supportedModels])
 
+  const toggleFeedExpand = useCallback((target: "think" | "diff") => {
+    setTranscript((items) => {
+      for (let index = items.length - 1; index >= 0; index -= 1) {
+        const entry = items[index]
+        const matchesThink = target === "think" && entry.label === "think" && entry.detailText
+        const matchesDiff =
+          target === "diff" && entry.kind === "meta" && entry.label === "diff" && entry.detailText
+        if (matchesThink || matchesDiff) {
+          return items.map((candidate, candidateIndex) =>
+            candidateIndex === index
+              ? { ...candidate, expanded: !candidate.expanded }
+              : candidate
+          )
+        }
+      }
+      return items
+    })
+    followTranscript()
+  }, [followTranscript])
+
   useKeyboard((key: KeyEvent) => {
     const character = getInputCharacter(key)
 
@@ -571,6 +627,10 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
     if (mode === "model") {
       if (key.name === "backspace" || key.name === "delete") {
         setModelSearch((value) => value.slice(0, -1))
+      } else if (character === "T") {
+        toggleModelPreference("thinking")
+      } else if (character === "F") {
+        toggleModelPreference("fast")
       } else if (isSearchInput(character)) {
         setModelSearch((value) => `${value}${character}`)
       }
@@ -586,6 +646,21 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
     if (mode === "input") {
       const pageSize = Math.max(1, transcriptViewportRows - 1)
 
+      if (key.ctrl && key.name === "t") {
+        toggleFeedExpand("think")
+        return
+      }
+
+      if (key.ctrl && key.name === "d") {
+        toggleFeedExpand("diff")
+        return
+      }
+
+      if (key.shift && (key.name === "return" || key.name === "enter")) {
+        setInput((value) => `${value}\n`)
+        return
+      }
+
       if (key.name === "up") {
         markScrollUnpinned()
         setScrollOffset((offset) => Math.min(maxScrollOffset, offset + 1))
@@ -646,9 +721,27 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
   return createElement(
     "box",
     { flexDirection: "column", height: rows, paddingX: 1 },
+    startupHeader.length
+      ? createElement(
+          "box",
+          { flexDirection: "column", flexShrink: 0, marginBottom: 1 },
+          startupHeader.map((line, index) =>
+            createElement(HeaderLine, { key: `header-${index}`, line })
+          )
+        )
+      : null,
     createElement(
       "box",
       { flexDirection: "column", height: transcriptViewportRows },
+      transcript.length === 0 && emptySessionHints.length
+        ? emptySessionHints.map((hint, index) =>
+            createElement("text", {
+              key: `hint-${index}`,
+              content: hint,
+              attributes: TextAttributes.DIM,
+            })
+          )
+        : null,
       visibleTranscriptLines.map((line) =>
         createElement(TranscriptLine, { key: line.id, line })
       )
@@ -662,6 +755,13 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
           }`
         )
       : null,
+    busy && activityLabel
+      ? createElement("text", {
+          content: `${["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"][activityFrame % 10]} ${activityLabel}…`,
+          fg: "yellow",
+          attributes: TextAttributes.DIM,
+        })
+      : null,
     mode === "command"
       ? createElement(
           "box",
@@ -705,7 +805,7 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
               attributes: TextAttributes.BOLD,
             }),
             createElement("text", {
-              content: "Type to search · Enter choose · Escape cancel",
+              content: `Type to search · T thinking ${modelThinking ? "on" : "off"} · F fast ${modelFast ? "on" : "off"} · Enter choose · Escape cancel`,
               fg: "gray",
             }),
             createElement("text", {
@@ -728,42 +828,90 @@ export function App({ cwd: cwdArg }: { cwd?: string }) {
               border: true,
               borderStyle: "single",
               borderColor: busy ? "yellow" : "green",
+              flexDirection: "column",
               marginTop: 1,
               paddingX: 1,
             },
-            createElement(TuiInput, {
-              focused: ready && !busy,
-              placeholder: busy
-                ? activityLabel
-                  ? `${["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"][activityFrame % 10]} ${activityLabel}… · Ctrl+C cancel`
-                  : "Ctrl+C cancel · waiting for agent…"
-                : ready
-                  ? "Ask or type /help"
-                  : "Loading Patze Code…",
-              value: input,
-              onInput: (value: string) => {
-                setInput(value)
-                if (busy) {
-                  return
-                }
-                if (value.startsWith("/") && !value.includes(" ")) {
-                  setMode("command")
-                } else {
-                  setMode("input")
-                }
-              },
-              onSubmit: submitInput,
+            createElement(
+              "box",
+              { flexDirection: "row", alignItems: "center" },
+              createElement("text", {
+                content: "> ",
+                attributes: TextAttributes.BOLD,
+              }),
+              createElement(TuiInput, {
+                focused: ready && !busy,
+                placeholder: busy
+                  ? activityLabel
+                    ? `${["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"][activityFrame % 10]} ${activityLabel}… · Ctrl+C cancel`
+                    : "Ctrl+C cancel · waiting for agent…"
+                  : ready
+                    ? composerPlaceholder
+                    : "Loading Patze Code…",
+                value: input,
+                onInput: (value: string) => {
+                  setInput(value)
+                  if (busy) {
+                    return
+                  }
+                  if (value.startsWith("/") && !value.includes(" ")) {
+                    setMode("command")
+                  } else {
+                    setMode("input")
+                  }
+                },
+                onSubmit: submitInput,
+              })
+            ),
+            createElement("text", {
+              content: `${composerModelLabel} · ${composerPathLabel}`,
+              attributes: TextAttributes.DIM,
             })
           ),
     createElement("text", {
       content: busy
         ? "Esc exit · Ctrl+C cancel run · agent executing"
-        : "Esc exit · Ctrl+C quit · /diff · /approve · /apply when patch ready",
+        : "Esc exit · Ctrl+C quit · / commands · ctrl+t thought · ctrl+d diff · /status",
       attributes: TextAttributes.DIM,
     })
   )
 }
 
+function trimComposerPrompt(value: string): string {
+  return value.replace(/^\s+|\s+$/g, "")
+}
+
+function shortenComposerPath(path: string): string {
+  const normalized = String(path || "").trim().replace(/\\/g, "/")
+  if ([...normalized].length <= 36) {
+    return normalized
+  }
+  const parts = normalized.split("/").filter(Boolean)
+  if (parts.length >= 2) {
+    const tail = `${parts[parts.length - 2]}/${parts[parts.length - 1]}`
+    const candidate = `…/${tail}`
+    if ([...candidate].length <= 36) {
+      return candidate
+    }
+  }
+  return `…${normalized.slice(-35)}`
+}
+
+function HeaderLine({ line }: { line: string }) {
+  const plain = stripAnsi(line)
+  const dim = line.includes("\x1b[2m") || plain.startsWith("Tip:") || plain.includes("Beta ·")
+  const warn = line.includes("\x1b[33m") || plain.startsWith("Heads up:")
+  return createElement("text", {
+    content: plain,
+    fg: warn ? "yellow" : dim ? "gray" : undefined,
+    attributes: dim ? TextAttributes.DIM : TextAttributes.NONE,
+  })
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "")
+}
+
 function TranscriptLine({ line }: { line: TranscriptLine }) {
   const color = {
     assistant: "white",

package/opentui/src/transcript-render.ts

@@ -12,6 +12,9 @@ export type TranscriptEntry = {
   label: string
   text: string
   upsertKey?: string
+  /** Full thinking body when collapsed summary is truncated. */
+  detailText?: string
+  expanded?: boolean
 }
 
 export type TranscriptPart = {
@@ -37,17 +40,65 @@ export function buildTranscriptLines(entries: TranscriptEntry[], columns: number
       entry.kind === "assistant"
         ? renderMarkdownLines(entry.text || "...", textWidth)
         : wrapText(entry.text || "...", textWidth).map((text) => ({
-            parts: [{ text }],
+            parts: parseCodexFeedParts(entry.kind, entry.label, text),
           }))
     )
 
-    return renderedLines.map((line, index) => ({
+    const lines = renderedLines.map((line, index) => ({
       id: `${entry.id}-${index}`,
       kind: entry.kind,
       label: index === 0 ? entry.label : "",
       parts: line.parts,
     }))
+
+    if (entry.label === "think" && entry.detailText) {
+      return appendExpandableDetailLines(lines, entry, textWidth, {
+        hint: `  (+${entry.detailText.length} chars · ctrl+t expand)`,
+        renderDetailLine: (text) => [{ text: `  ${text}`, color: "gray" as const, dimColor: true }],
+      })
+    }
+
+    if (entry.kind === "meta" && entry.label === "diff" && entry.detailText) {
+      return appendExpandableDetailLines(lines, entry, textWidth, {
+        hint: `  (+${entry.detailText.split("\n").length} lines · ctrl+d expand)`,
+        renderDetailLine: (text) => parseCodexDiffParts(text.startsWith("  ") ? text : `  ${text}`),
+      })
+    }
+
+    return lines
+  })
+}
+
+function appendExpandableDetailLines(
+  lines: TranscriptLine[],
+  entry: TranscriptEntry,
+  textWidth: number,
+  options: {
+    hint: string
+    renderDetailLine: (text: string) => TranscriptPart[]
+  }
+): TranscriptLine[] {
+  if (entry.expanded) {
+    const detailLines = entry.detailText!
+      .split("\n")
+      .flatMap((rawLine, index) =>
+        wrapText(rawLine, textWidth - 2).map((text, wrapIndex) => ({
+          id: `${entry.id}-detail-${index}-${wrapIndex}`,
+          kind: entry.kind,
+          label: "",
+          parts: options.renderDetailLine(text),
+        }))
+      )
+    return [...lines, ...detailLines]
+  }
+
+  lines.push({
+    id: `${entry.id}-expand-hint`,
+    kind: entry.kind,
+    label: "",
+    parts: [{ text: options.hint, color: "gray", dimColor: true }],
   })
+  return lines
 }
 
 function trimTrailingBlankLines(lines: Array<{ parts: TranscriptPart[] }>) {
@@ -156,6 +207,97 @@ function renderMarkdownLines(value: string, width: number) {
   return lines
 }
 
+function parseCodexFeedParts(kind: TranscriptEntryKind, label: string, text: string): TranscriptPart[] {
+  if (kind === "meta" && label === "diff") {
+    return parseCodexDiffParts(text)
+  }
+
+  if (kind === "tool") {
+    const match = text.match(/^([…✓✗])\s+(.*)$/)
+    if (match) {
+      const glyph = match[1]
+      const body = match[2] ?? ""
+      const glyphColor =
+        glyph === "✓" ? "green" : glyph === "✗" ? "red" : ("yellow" as const)
+      const bodyParts = parseCodexToolBodyParts(body)
+      return [{ text: `${glyph} `, color: glyphColor, bold: true }, ...bodyParts]
+    }
+    return parseCodexToolBodyParts(text)
+  }
+
+  if (kind === "status" || (kind === "meta" && label === "done")) {
+    if (text.startsWith("→ ")) {
+      return [{ text, color: "cyan" }]
+    }
+    if (text.startsWith("…")) {
+      return [{ text, color: "gray", dimColor: true }]
+    }
+    if (text.startsWith("✓")) {
+      return [{ text, color: "green" }]
+    }
+    if (text.startsWith("✗")) {
+      return [{ text, color: "red" }]
+    }
+    if (text.startsWith("○")) {
+      return [{ text, color: "yellow" }]
+    }
+    if (text.startsWith("●")) {
+      return [{ text, color: "cyan", bold: true }]
+    }
+  }
+
+  if (kind === "status" && label === "think") {
+    if (text.startsWith("…")) {
+      return [{ text, color: "gray", dimColor: true }]
+    }
+    if (text.startsWith("✓")) {
+      return [{ text, color: "green" }]
+    }
+  }
+
+  if (kind === "meta") {
+    if (text.startsWith("✓ completed")) {
+      return [{ text, color: "green", bold: true }]
+    }
+    if (text.startsWith("deliverables")) {
+      return [{ text, color: "cyan" }]
+    }
+  }
+
+  return [{ text }]
+}
+
+function parseCodexToolBodyParts(body: string): TranscriptPart[] {
+  if (body.startsWith("+ create")) {
+    return [{ text: body, color: "green" }]
+  }
+  if (body.startsWith("~ modify")) {
+    return [{ text: body, color: "yellow" }]
+  }
+  if (body.startsWith("- delete")) {
+    return [{ text: body, color: "red" }]
+  }
+  if (body.startsWith("▸")) {
+    return [{ text: body, color: "magenta" }]
+  }
+  return [{ text: body }]
+}
+
+function parseCodexDiffParts(text: string): TranscriptPart[] {
+  const trimmed = text.trim()
+  if (trimmed === "…") {
+    return [{ text: "  …", color: "gray", dimColor: true }]
+  }
+  const line = text.startsWith("  ") ? text : `  ${text}`
+  if (line.startsWith("  - ")) {
+    return [{ text: line, color: "red" }]
+  }
+  if (line.startsWith("  + ")) {
+    return [{ text: line, color: "green" }]
+  }
+  return [{ text: line, color: "gray", dimColor: true }]
+}
+
 function wrapText(value: string, width: number) {
   const lines: string[] = []