dsh-code 1.0.6 → 1.2.0

package/src/render/export.ts

@@ -1,95 +1,116 @@
-/**
- * Markdown export of one transcript view: the /export command's pure
- * formatter. Deterministic and side-effect free — the runner owns the file
- * write, so tests drive the builder with folded views directly.
- *
- * @module @deepseek-ai/dsh-code/render/export
- */
-
-import { assertNever } from '@deepseek-ai/dsh-util-values'
-import { fileLabels, imageLabels, type TranscriptView } from './projection.ts'
-
-/**
- * Render the transcript as a standalone markdown document.
- * @param view - the folded transcript view to export.
- * @param sessionId - the full session identity for the header.
- * @returns the complete markdown text.
- */
-/** Both user and queued rows export the same attachment label block. */
-const attachmentLabels = (entry: { images?: readonly unknown[]; files?: readonly unknown[] }): string =>
-  [imageLabels(entry.images as never), fileLabels(entry.files as never)].filter(label => label !== '').join('\n')
-
-export function buildExportMarkdown(view: TranscriptView, sessionId: string): string {
-  const out: string[] = [
-    view.title === ''
-      ? `# dsh session ${sessionId}`
-      : `# ${view.title}`,
-    `> session ${sessionId}`,
-    '',
-  ]
-  // The effective system prompt (v3 surface nodes) heads the export in a
-  // collapsed block: visible when audited, out of the way when scrolled.
-  if (view.systemPrompt !== '') {
-    out.push('<details><summary>system prompt</summary>', '', view.systemPrompt, '', '</details>', '')
-  }
-  for (const entry of view.entries) {
-    switch (entry.kind) {
-      case 'user':
-        if (entry.notice) {
-          out.push(`> ⤷ context: ${entry.text}`, '')
-        } else {
-          const attachments = attachmentLabels(entry)
-          out.push('## user', '', entry.text, ...(attachments === '' ? [] : [attachments]), '')
-        }
-        break
-      case 'assistant':
-        if (entry.reasoning !== '') {
-          out.push('<details><summary>thinking</summary>', '', entry.reasoning, '', '</details>', '')
-        }
-        out.push('## assistant', '', entry.text, '')
-        break
-      case 'tool':
-        out.push(`### tool \`${entry.name}\``, '')
-        if (entry.preview !== '') out.push(`- args: ${entry.preview}`)
-        if (entry.summary !== '') out.push(`- ${entry.state === 'error' ? 'error' : 'result'}: ${entry.summary}`)
-        out.push('')
-        break
-      case 'command':
-        out.push(`### /${entry.name}${entry.args === '' ? '' : ` ${entry.args}`}`, '')
-        if (entry.summary !== '') out.push(`- ${entry.state === 'error' ? 'error' : 'result'}: ${entry.summary}`)
-        out.push('')
-        break
-      case 'error':
-        out.push(`> ⨯ ${entry.text}`, '')
-        break
-      case 'turn-marker':
-        out.push(`> ${entry.text}`, '')
-        break
-      case 'compaction':
-        out.push(entry.ok
-          ? `> compacted ~${entry.tokens} tokens`
-          : `> compaction failed: ${entry.error}`, '')
-        break
-      case 'retry':
-        out.push(`> retry ${entry.attempt}/${entry.max} (${entry.code})`, '')
-        break
-      case 'files':
-        out.push(`> files changed: ${entry.paths.join(', ')}`, '')
-        break
-      case 'pending':
-        // Codex PendingSteer: queued prompts export like ordinary user rows.
-        out.push('## user', '', entry.text, ...(attachmentLabels(entry) === '' ? [] : [attachmentLabels(entry)]), '')
-        break
-      default:
-        assertNever(entry, 'transcript entry kind')
-    }
-  }
-  if (view.streaming !== '') out.push('## assistant (streaming)', '', view.streaming, '')
-  const { stats } = view
-  out.push('---', '')
-  out.push(`- model: ${view.model === '' ? '(none yet)' : view.model}`)
-  out.push(`- turns: ${stats.turns} · steps: ${stats.steps}`)
-  out.push(`- tokens: ↑${stats.usage.inputTokens} ↓${stats.usage.outputTokens} · cache read ${stats.usage.cacheReadTokens}`)
-  out.push(`- todos: ${view.todos.length}`)
-  return out.join('\n')
-}
+/**
+ * Markdown export of one transcript view: the /export command's pure
+ * formatter. Deterministic and side-effect free — the runner owns the file
+ * write, so tests drive the builder with folded views directly.
+ *
+ * @module @deepseek-ai/dsh-code/render/export
+ */
+
+import { assertNever } from '@deepseek-ai/dsh-util-values'
+import { fileLabels, imageLabels, type TranscriptView } from './projection.ts'
+import { t } from '../i18n.ts'
+
+/**
+ * Render the transcript as a standalone markdown document.
+ * @param view - the folded transcript view to export.
+ * @param sessionId - the full session identity for the header.
+ * @returns the complete markdown text.
+ */
+/** Both user and queued rows export the same attachment label block. */
+const attachmentLabels = (entry: { images?: readonly unknown[]; files?: readonly unknown[] }): string =>
+  [imageLabels(entry.images as never), fileLabels(entry.files as never)].filter(label => label !== '').join('\n')
+
+export function buildExportMarkdown(view: TranscriptView, sessionId: string): string {
+  const out: string[] = [
+    view.title === ''
+      ? `# dsh session ${sessionId}`
+      : `# ${view.title}`,
+    `> session ${sessionId}`,
+    '',
+  ]
+  // The effective system prompt (v3 surface nodes) heads the export in a
+  // collapsed block: visible when audited, out of the way when scrolled.
+  if (view.systemPrompt !== '') {
+    out.push('<details><summary>system prompt</summary>', '', view.systemPrompt, '', '</details>', '')
+  }
+  for (const entry of view.entries) {
+    switch (entry.kind) {
+      case 'user':
+        if (entry.notice) {
+          out.push(`> ⤷ context: ${entry.text}`, '')
+        } else {
+          const attachments = attachmentLabels(entry)
+          // How the prompt was delivered is part of the record: a queued or
+          // steered message reads differently from one typed into an idle
+          // composer. Ordinary prompts keep the bare heading.
+          const marker = entry.delivery === undefined ? '' : ` (${t(entry.delivery === 'queued' ? 'entry.delivery.queued' : 'entry.delivery.steered')})`
+          out.push(`## user${marker}`, '', entry.text, ...(attachments === '' ? [] : [attachments]), '')
+        }
+        break
+      case 'assistant':
+        if (entry.reasoning !== '') {
+          out.push('<details><summary>thinking</summary>', '', entry.reasoning, '', '</details>', '')
+        }
+        out.push('## assistant', '', entry.text, '')
+        break
+      case 'tool':
+        out.push(`### tool \`${entry.name}\``, '')
+        if (entry.preview !== '') out.push(`- args: ${entry.preview}`)
+        if (entry.subs.length > 0) {
+          for (const sub of entry.subs) {
+            const label = sub.preview === '' ? sub.name : `${sub.name} ${sub.preview}`
+            out.push(`- dispatch: ${sub.state === 'error' ? 'error' : sub.state === 'running' ? 'running' : 'ok'} · ${label}${sub.summary === '' ? '' : ` · ${sub.summary}`}`)
+          }
+          if (entry.subsDropped > 0) out.push(`- dispatch: … ${entry.subsDropped} earlier dispatch${entry.subsDropped === 1 ? '' : 'es'}`)
+        }
+        if (entry.summary !== '') out.push(`- ${entry.state === 'error' ? 'error' : 'result'}: ${entry.summary}`)
+        out.push('')
+        break
+      case 'command':
+        out.push(`### /${entry.name}${entry.args === '' ? '' : ` ${entry.args}`}`, '')
+        if (entry.summary !== '') out.push(`- ${entry.state === 'error' ? 'error' : 'result'}: ${entry.summary}`)
+        out.push('')
+        break
+      case 'error':
+        out.push(`> ⨯ ${entry.text}`, '')
+        break
+      case 'turn-marker':
+        out.push(`> ${entry.text}`, '')
+        break
+      case 'compaction':
+        out.push(entry.ok
+          ? `> compacted ~${entry.tokens} tokens`
+          : `> compaction failed: ${entry.error}`, '')
+        break
+      case 'retry':
+        out.push(`> retry ${entry.attempt}/${entry.max} (${entry.code})`, '')
+        break
+      case 'files':
+        out.push(`> files changed: ${entry.paths.join(', ')}`, '')
+        break
+      case 'workflow':
+        out.push(`### workflow \`${entry.name}\` (${entry.state})`, '')
+        for (const member of entry.members) {
+          const phase = member.phase === '' ? '' : ` [${member.phase}]`
+          out.push(`- ${member.outcome}: ${member.label}${phase}`)
+        }
+        if (entry.membersDropped > 0) out.push(`- … ${entry.membersDropped} earlier member${entry.membersDropped === 1 ? '' : 's'}`)
+        out.push('')
+        break
+      case 'pending':
+        // Codex PendingSteer: queued prompts export like ordinary user rows.
+        out.push('## user', '', entry.text, ...(attachmentLabels(entry) === '' ? [] : [attachmentLabels(entry)]), '')
+        break
+      default:
+        assertNever(entry, 'transcript entry kind')
+    }
+  }
+  if (view.streaming !== '') out.push('## assistant (streaming)', '', view.streaming, '')
+  const { stats } = view
+  out.push('---', '')
+  out.push(`- model: ${view.model === '' ? '(none yet)' : view.model}`)
+  out.push(`- turns: ${stats.turns} · steps: ${stats.steps}`)
+  out.push(`- tokens: ↑${stats.usage.uncachedInputTokens} ↓${stats.usage.outputTokens} · cache read ${stats.usage.cacheReadTokens} · cache write ${stats.usage.cacheWriteTokens}`)
+  out.push(`- todos: ${view.todos.length}`)
+  return out.join('\n')
+}

package/src/render/ime-cursor.ts

@@ -0,0 +1,147 @@
+/**
+ * IME cursor anchoring for the composer.
+ *
+ * Ink keeps the real terminal cursor hidden and parks it just below the
+ * dynamic tree (after the status row). IME composition text and candidate
+ * windows anchor to that real cursor cell - VS Code's integrated terminal
+ * positions its hidden IME textarea there, and Windows consoles behave the
+ * same - so CJK input appeared at the bottom of the screen instead of at the
+ * caret. The anchor moves the real cursor onto the caret cell without
+ * touching Ink's relative erase ledger:
+ *
+ * - the displacement is owned: before any foreign write or re-anchor, the
+ *   wrapper cancels it (cursor down, column 1), so every writer - Ink's
+ *   log-update rewrites, the resize replay, protocol pushes - keeps seeing
+ *   the cursor exactly where it was left;
+ * - log-update frame chunks (which start with the erase-line sequence) get
+ *   the anchor re-appended inside the same write, so a repaint can never
+ *   leave the cursor behind - in particular the caret blink keeps the anchor
+ *   stable while an IME composition is open, because the terminal parses the
+ *   rewrite and the re-anchor as one atomic update.
+ *
+ * @module @deepseek-ai/dsh-code/render/ime-cursor
+ */
+
+import { useEffect, useRef } from 'react'
+import { useStdout } from 'ink'
+
+/** Cancel `rows` of owned upward displacement and return to column 1. */
+export function imeCursorRestore(rows: number): string {
+  return rows > 0 ? `\x1b[${rows}B\r` : ''
+}
+
+/** Move onto the caret cell: `rows` up from Ink's parked row, 0-based column. */
+export function imeCursorMove(rows: number, column: number): string {
+  return rows > 0 ? `\x1b[${rows}A\x1b[${column + 1}G` : ''
+}
+
+/**
+ * Rows between the caret cell and Ink's parked cursor row: the band's bottom
+ * blank row, the editor window rows below the caret, the status footer, and
+ * Ink's own below-frame row. Rows above the composer (gutter, live content)
+ * never enter this distance.
+ */
+export function imeCursorRowsUp(input: {
+  editorWindowRows: number
+  caretRowInWindow: number
+  rowsBelowComposer: number
+}): number {
+  return Math.max(1, input.editorWindowRows - input.caretRowInWindow + input.rowsBelowComposer)
+}
+
+/** log-update chunks start with the erase-line sequence; a chunk without it
+ * leaves no frame behind, so the next commit re-applies the anchor. */
+const FRAME_CHUNK_MARKER = '\x1b[2K'
+
+/** The installed anchor handle. */
+export interface ImeCursorAnchor {
+  /** Anchor on the caret cell: `rows` above Ink's parked row at the 0-based
+   * `column`; `rows <= 0` releases the anchor. */
+  anchor(rows: number, column: number): void
+  /** Cancel the displacement, restore the original write path, and detach. */
+  release(): void
+}
+
+const ANCHOR_STATE = Symbol.for('dsh-code.ime-cursor-anchor')
+
+/**
+ * Take over `stream.write` so the anchor displacement stays invisible to every
+ * other writer. Idempotent per stream: a second install returns the live
+ * handle. Returns `undefined` on non-TTY streams where anchoring is meaningless.
+ */
+export function installImeCursorAnchor(stream: NodeJS.WriteStream): ImeCursorAnchor | undefined {
+  if (stream?.isTTY !== true) return undefined
+  const target = stream as NodeJS.WriteStream & { [ANCHOR_STATE]?: ImeCursorAnchor | undefined }
+  const installed = target[ANCHOR_STATE]
+  if (installed !== undefined) return installed
+  const originalWrite = target.write.bind(target) as (...args: unknown[]) => unknown
+  let rows = 0
+  let column = -1
+  let detached = false
+  const anchor: ImeCursorAnchor = {
+    anchor(nextRows, nextColumn) {
+      if (detached) return
+      if (nextRows <= 0) {
+        if (rows !== 0) originalWrite(imeCursorRestore(rows))
+        rows = 0
+        column = -1
+        return
+      }
+      if (rows === nextRows && column === nextColumn) return
+      originalWrite(imeCursorRestore(rows) + imeCursorMove(nextRows, nextColumn))
+      rows = nextRows
+      column = nextColumn
+    },
+    release() {
+      if (detached) return
+      detached = true
+      if (rows !== 0) originalWrite(imeCursorRestore(rows))
+      rows = 0
+      column = -1
+      target.write = originalWrite as typeof target.write
+      delete target[ANCHOR_STATE]
+    },
+  }
+  target.write = ((chunk: unknown, ...rest: unknown[]) => {
+    const ownedRows = rows
+    const ownedColumn = column
+    if (ownedRows === 0 || typeof chunk !== 'string') {
+      if (ownedRows !== 0) {
+        originalWrite(imeCursorRestore(ownedRows))
+        rows = 0
+        column = -1
+      }
+      return originalWrite(chunk, ...rest)
+    }
+    const reanchor = chunk.startsWith(FRAME_CHUNK_MARKER)
+    rows = reanchor ? ownedRows : 0
+    column = reanchor ? ownedColumn : -1
+    return originalWrite(imeCursorRestore(ownedRows) + chunk + (reanchor ? imeCursorMove(ownedRows, ownedColumn) : ''), ...rest)
+  }) as typeof target.write
+  target[ANCHOR_STATE] = anchor
+  return anchor
+}
+
+/**
+ * Keep the real terminal cursor on the composer's caret cell while `active`
+ * (the editable composer). The second effect runs after every commit without
+ * a dep list: frame rewrites restore the anchor themselves, but any other
+ * write (protocol push, resize replay) leaves the cursor at Ink's parked
+ * position, and the next commit re-anchors it.
+ */
+export function useImeCursorAnchor(active: boolean, rows: number, column: number): void {
+  const { stdout } = useStdout()
+  const anchorRef = useRef<ImeCursorAnchor | undefined>(undefined)
+  useEffect(() => {
+    if (stdout === undefined) return undefined
+    const installed = installImeCursorAnchor(stdout)
+    anchorRef.current = installed
+    return () => {
+      installed?.release()
+      if (anchorRef.current === installed) anchorRef.current = undefined
+    }
+  }, [stdout])
+  useEffect(() => {
+    anchorRef.current?.anchor(active && rows > 0 ? rows : 0, column)
+  })
+}

package/src/render/inspector.ts

@@ -24,6 +24,48 @@ export function layoutGutterRows(rows: number): 0 | 1 {
   return Math.max(1, Math.floor(rows)) >= 14 ? 1 : 0
 }
 
+/** Measured chrome that sits below (or in) the live region. */
+export interface LiveRegionChrome {
+  /** Terminal rows. */
+  readonly terminalRows: number
+  /** Editor rows inside the composer band (frozen reports 1). */
+  readonly composerRows: number
+  /** Status footer rows. */
+  readonly statusBarRows: 1 | 2
+  /** Completion menu rows (0 when closed). */
+  readonly menuRows: number
+  /** Transcript-to-composer gutter. */
+  readonly gutterRows: 0 | 1
+  /** Notice line present. */
+  readonly notice: boolean
+  /** Todo summary line present. */
+  readonly todo: boolean
+  /** Agents summary line present. */
+  readonly agents: boolean
+}
+
+/**
+ * Rows left for live transcript and streaming after pinning the composer and
+ * status at the bottom. Variable chrome (menu, notice, todos, agents, extra
+ * status row, extra editor rows) is deducted here so those rows cover the
+ * live region instead of growing the tree and moving the bottom bar.
+ */
+export function liveRegionBudget(chrome: LiveRegionChrome): number {
+  const terminal = Math.max(1, Math.floor(chrome.terminalRows))
+  const editor = Math.max(1, Math.floor(chrome.composerRows))
+  const band = editor + 2
+  const status = chrome.statusBarRows === 2 ? 2 : 1
+  const menu = Math.max(0, Math.floor(chrome.menuRows))
+  const gutter = chrome.gutterRows
+  const notice = chrome.notice ? 1 : 0
+  const todo = chrome.todo ? 1 : 0
+  const agents = chrome.agents ? 1 : 0
+  // Two spare rows: Ink's parked cursor, plus one so the painted tree never
+  // reaches stdout.rows (equality takes the full-terminal clear path).
+  const inkSpare = 2
+  return Math.max(1, terminal - band - status - menu - gutter - notice - todo - agents - inkSpare)
+}
+
 /**
  * Keep the inspector plus its persistent status/composer chrome below
  * `stdout.rows`: at equality Ink clears the terminal and rewrites all