dsh-code 0.2.0 → 0.4.0

package/src/render/export.ts

@@ -0,0 +1,81 @@
+/**
+ * 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-llm'
+import 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.
+ */
+export function buildExportMarkdown(view: TranscriptView, sessionId: string): string {
+  const out: string[] = [
+    view.title === ''
+      ? `# dsh session ${sessionId}`
+      : `# ${view.title}`,
+    `> session ${sessionId}`,
+    '',
+  ]
+  for (const entry of view.entries) {
+    switch (entry.kind) {
+      case 'user':
+        if (entry.notice) {
+          out.push(`> ⤷ context: ${entry.text}`, '')
+        } else {
+          out.push('## user', '', entry.text, '')
+        }
+        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
+      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')
+}

package/src/render/inspector.ts

@@ -0,0 +1,79 @@
+/** Pure viewport, selection, and scrolling rules for exclusive TUI panels. */
+
+/** Terminal-space allocation for the inspector's one dynamic screen. */
+export interface InspectorViewport {
+  /** Maximum dynamic rows, kept strictly below the terminal height. */
+  maxHeight: number
+  /** Rows available to the selected entry after border, title, and footer. */
+  bodyRows: number
+  /** Columns available inside the horizontal border and padding. */
+  contentColumns: number
+  /** Tiny terminals use a borderless one-line close hint. */
+  compact: boolean
+}
+
+/** The three-row read-only composer frame plus its one-row status footer. */
+const INSPECTOR_CHROME_ROWS = 4
+
+/**
+ * Keep the inspector plus its persistent status/composer chrome below
+ * `stdout.rows`: at equality Ink clears the terminal and rewrites all
+ * accumulated `<Static>` output on every frame.
+ */
+export function panelViewport(columns: number, rows: number): InspectorViewport {
+  const safeColumns = Math.max(1, Math.floor(columns))
+  const safeRows = Math.max(1, Math.floor(rows))
+  // Two spare rows cover Ink's first-frame transition from existing Static
+  // scrollback into a tall dynamic panel. A one-row margin is insufficient:
+  // the transition can still take the full-terminal rewrite path at rows - 1.
+  const maxHeight = Math.max(0, Math.min(
+    safeRows - 2 - INSPECTOR_CHROME_ROWS,
+    Math.floor(safeRows / 2),
+  ))
+  const compact = maxHeight < 5 || safeColumns < 8
+  return {
+    maxHeight,
+    bodyRows: compact ? 0 : maxHeight - 4,
+    contentColumns: compact ? Math.max(1, safeColumns - 1) : Math.max(1, safeColumns - 4),
+    compact,
+  }
+}
+
+/** Backward-compatible name for the Ctrl+O-specific caller and tests. */
+export function inspectorViewport(columns: number, rows: number): InspectorViewport {
+  return panelViewport(columns, rows)
+}
+
+/** Clamp a first-visible row to the range representable by one viewport. */
+export function clampScroll(offset: number, totalRows: number, visibleRows: number): number {
+  const total = Math.max(0, Math.floor(totalRows))
+  const size = Math.max(0, Math.floor(visibleRows))
+  const last = Math.max(0, total - size)
+  return Math.max(0, Math.min(Math.floor(offset), last))
+}
+
+/** Move a viewport by a signed row delta without escaping its content. */
+export function moveScroll(offset: number, delta: number, totalRows: number, visibleRows: number): number {
+  return clampScroll(offset + delta, totalRows, visibleRows)
+}
+
+/** Keep one focused row visible while preserving the current window when possible. */
+export function revealRow(offset: number, row: number, totalRows: number, visibleRows: number): number {
+  const size = Math.max(1, Math.floor(visibleRows))
+  const target = Math.max(0, Math.min(Math.floor(row), Math.max(0, totalRows - 1)))
+  if (target < offset) return clampScroll(target, totalRows, size)
+  if (target >= offset + size) return clampScroll(target - size + 1, totalRows, size)
+  return clampScroll(offset, totalRows, size)
+}
+
+/** Center a selected list row where possible, clamped at both ends. */
+export function selectionWindow(cursor: number, totalRows: number, visibleRows: number): number {
+  return clampScroll(cursor - Math.floor(Math.max(1, visibleRows) / 2), totalRows, visibleRows)
+}
+
+/** Follow appended history only while the inspector cursor was at the tail. */
+export function followInspectorCursor(cursor: number, previousLength: number, nextLength: number): number {
+  const nextLast = Math.max(0, nextLength - 1)
+  if (cursor >= Math.max(0, previousLength - 1)) return nextLast
+  return Math.min(cursor, nextLast)
+}

package/src/render/lines.ts

@@ -0,0 +1,207 @@
+/** Width-safe styled physical rows for bounded terminal panels. */
+
+import type { TranscriptEntry } from './projection.ts'
+import type { ToolDetail } from './tool-detail.ts'
+import { renderMarkdown, visibleColumns, type MdStyle } from './markdown.ts'
+import { formatTokens } from './status.ts'
+import { displayText } from './text.ts'
+
+/** Presentation classes mapped to Ink colors by the app boundary. */
+export type LineStyle = MdStyle | 'brand' | 'success' | 'error' | 'warn' | 'dimItalic'
+
+/** One styled run within a physical terminal row. */
+export interface StyledSegment {
+  text: string
+  style: LineStyle
+}
+
+/** One row guaranteed not to exceed the requested terminal width. */
+export interface StyledLine {
+  segments: readonly StyledSegment[]
+}
+
+/** Construct one segment without leaking mutable objects into cached rows. */
+export function lineSegment(text: string, style: LineStyle = 'plain'): StyledSegment {
+  return { text, style }
+}
+
+/** Append a character while merging adjacent runs with the same style. */
+function appendSegment(target: StyledSegment[], text: string, style: LineStyle): void {
+  const previous = target[target.length - 1]
+  if (previous?.style === style) {
+    target[target.length - 1] = { text: previous.text + text, style }
+    return
+  }
+  target.push({ text, style })
+}
+
+/**
+ * Sanitize and hard-wrap styled content into exact physical rows.
+ * Tabs become two visible spaces because terminal tab stops are contextual
+ * and therefore cannot participate in a deterministic row budget.
+ */
+export function styledLines(segments: readonly StyledSegment[], columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  const lines: StyledLine[] = []
+  let current: StyledSegment[] = []
+  let used = 0
+  const flush = (): void => {
+    lines.push({ segments: current })
+    current = []
+    used = 0
+  }
+
+  for (const segment of segments) {
+    const safe = displayText(segment.text).replaceAll('\t', '  ').replaceAll('\r', '')
+    for (const char of safe) {
+      if (char === '\n') {
+        flush()
+        continue
+      }
+      const cells = visibleColumns(char)
+      if (used > 0 && used + cells > width) flush()
+      appendSegment(current, char, segment.style)
+      used += cells
+    }
+  }
+  if (current.length > 0 || lines.length === 0) flush()
+  return lines
+}
+
+/** Plain/dim text convenience over {@link styledLines}. */
+export function textLines(text: string, columns: number, style: LineStyle = 'plain'): readonly StyledLine[] {
+  return styledLines([lineSegment(text, style)], columns)
+}
+
+/** Markdown rows re-hardened so a single long word cannot escape the budget. */
+export function markdownLines(text: string, columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  const parsed = renderMarkdown(displayText(text), Math.max(10, width))
+  return parsed.flatMap(line => styledLines(
+    line.segments.map(segment => lineSegment(segment.text, segment.style)),
+    width,
+  ))
+}
+
+/** Expanded structured tool detail as scrollable, width-safe rows. */
+function toolDetailLines(detail: ToolDetail, columns: number): readonly StyledLine[] {
+  switch (detail.kind) {
+    case 'diff':
+      return detail.diffs.flatMap(diff => [
+        ...styledLines([
+          lineSegment('  ── ', 'dim'),
+          lineSegment(diff.path, 'dim'),
+          lineSegment(diff.truncated ? ' (diff truncated)' : '', 'dim'),
+        ], columns),
+        ...diff.lines.flatMap(line => styledLines([
+          lineSegment(`  ${line.mark}${line.text}`, line.mark === '+' ? 'success' : line.mark === '-' ? 'error' : 'dim'),
+        ], columns)),
+      ])
+    case 'read':
+      return [
+        ...textLines(
+          `  ── ${detail.path} · lines ${detail.offset}-${detail.lines.length > 0 ? detail.lines[detail.lines.length - 1]!.number : detail.offset - 1} of ${detail.totalLines}${detail.truncated ? ' (window truncated)' : ''}`,
+          columns,
+          'dim',
+        ),
+        ...detail.lines.flatMap(line => textLines(`  ${String(line.number).padStart(5, ' ')} | ${line.text}`, columns, 'dim')),
+      ]
+    case 'web-search':
+      return [
+        ...detail.sources.flatMap(source => [
+          ...styledLines([
+            lineSegment(`  ? ${source.title ?? source.url}`, 'brand'),
+            lineSegment(` - ${source.url}`, 'dim'),
+          ], columns),
+          ...(source.snippet === '' ? [] : textLines(`    ${source.snippet}`, columns, 'dim')),
+        ]),
+        ...textLines(`  ${detail.sources.length} sources${detail.truncated ? ' (capped)' : ''}`, columns, 'dim'),
+      ]
+    case 'web-fetch':
+      return textLines(`  ${detail.url} · HTTP ${detail.statusCode}`, columns, 'dim')
+    case 'raw':
+      return [
+        ...textLines(`  ${detail.text}`, columns, 'dim'),
+        ...textLines(detail.truncated ? '  … (output truncated)' : '  (end of output)', columns, 'dim'),
+      ]
+    default: {
+      const exhaustive: never = detail
+      return exhaustive
+    }
+  }
+}
+
+/**
+ * Convert one durable transcript entry to its complete scrollable row model.
+ * The source entry stays intact; only the caller's visible slice is rendered.
+ */
+export function transcriptEntryLines(entry: TranscriptEntry, columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  switch (entry.kind) {
+    case 'user':
+      return styledLines([
+        lineSegment(entry.notice ? '⤷ ' : '❯ ', entry.notice ? 'dim' : 'brand'),
+        lineSegment(entry.text, entry.notice ? 'dim' : 'plain'),
+      ], width)
+    case 'assistant':
+      return [
+        ...(entry.reasoning === ''
+          ? []
+          : styledLines([
+            lineSegment('  ✻ ', 'dimItalic'),
+            lineSegment(entry.reasoning, 'dimItalic'),
+          ], width)),
+        ...markdownLines(entry.text, width),
+      ]
+    case 'tool': {
+      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
+      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
+      return [
+        ...styledLines([
+          lineSegment(`${mark} `, markStyle),
+          lineSegment(entry.name, 'brand'),
+          lineSegment(entry.preview === '' ? '' : ` ${entry.preview}`, 'dim'),
+        ], width),
+        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
+        ...(entry.detail === undefined ? [] : toolDetailLines(entry.detail, width)),
+      ]
+    }
+    case 'command': {
+      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
+      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
+      return [
+        ...styledLines([
+          lineSegment(`${mark} `, markStyle),
+          lineSegment(`/${entry.name}`, 'brand'),
+          lineSegment(entry.args === '' ? '' : ` ${entry.args}`, 'dim'),
+        ], width),
+        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
+      ]
+    }
+    case 'turn-marker':
+      return textLines(`  ⏹ ${entry.text}`, width, 'dim')
+    case 'compaction':
+      return textLines(entry.ok
+        ? `  ⧉ compacted ~${formatTokens(entry.tokens)} tokens`
+        : `  ⧉ compaction failed: ${entry.error}`, width, 'dim')
+    case 'retry':
+      return textLines(
+        `  ↻ retry ${entry.attempt}/${entry.max} · ${entry.code} · ${Math.round(entry.delayMs / 100) / 10}s`,
+        width,
+        entry.state === 'running' ? 'warn' : 'dim',
+      )
+    case 'files':
+      return entry.paths.length === 0
+        ? textLines('  ⎄ no changed files', width, 'dim')
+        : [
+          ...textLines(`  ⎄ ${entry.paths.length} changed file${entry.paths.length === 1 ? '' : 's'}`, width, 'dim'),
+          ...entry.paths.flatMap(path => textLines(`    ${path}`, width, 'dim')),
+        ]
+    case 'error':
+      return textLines(entry.text, width, 'error')
+    default: {
+      const exhaustive: never = entry
+      return exhaustive
+    }
+  }
+}

package/src/render/markdown.ts

@@ -0,0 +1,235 @@
+/**
+ * Terminal markdown renderer for assistant replies: a pure GFM-subset
+ * block/inline parser producing styled line segments the Ink renderer maps
+ * to colored text. No ANSI here — the app owns color mapping, tests own the
+ * structure. The subset mirrors what agent replies actually emit: headings,
+ * emphasis, inline/fenced code, flat lists, blockquotes, links, rules, and
+ * wrapped paragraphs. Unknown syntax degrades to plain text (never throws).
+ *
+ * @module @deepseek-ai/dsh-code/render/markdown
+ */
+
+/** Style classes the renderer emits; the app maps them to colors/props. */
+export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'dim' | 'strike'
+
+/** One styled run of text. */
+export interface MdSegment {
+  /** Visible text (no ANSI). */
+  text: string
+  /** Presentation class for the app's color map. */
+  style: MdStyle
+}
+
+/** One rendered line: a sequence of styled runs. */
+export interface MdLine {
+  segments: readonly MdSegment[]
+}
+
+/** Plain segment helper. */
+function seg(text: string, style: MdStyle = 'plain'): MdSegment {
+  return { text, style }
+}
+
+/** Visible width of a run in columns (CJK counts double). */
+export function visibleColumns(text: string): number {
+  let columns = 0
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0
+    columns += code > 0x2e7f ? 2 : 1
+  }
+  return columns
+}
+
+/** Walk a segment list, breaking it into lines that fit `width` columns. */
+function wrapSegments(segments: readonly MdSegment[], width: number): readonly MdSegment[][] {
+  const lines: MdSegment[][] = []
+  let current: MdSegment[] = []
+  let used = 0
+  for (const segment of segments) {
+    // Break the segment at spaces into words so long runs wrap mid-text.
+    const words = segment.text.split(/( )/u)
+    for (const word of words) {
+      if (word === '') continue
+      const columns = visibleColumns(word)
+      if (used + columns > width && used > 0) {
+        lines.push(current)
+        current = []
+        used = 0
+      }
+      // A single word wider than the line still goes on its own line.
+      current.push({ text: word, style: segment.style })
+      used += columns
+    }
+  }
+  if (current.length > 0) lines.push(current)
+  // Drop the trailing space a wrapped line picked up before the break.
+  return lines.map(line => {
+    const last = line[line.length - 1]
+    if (last !== undefined && last.text === ' ' && line.length > 1) return line.slice(0, -1)
+    return line
+  })
+}
+
+/** Join adjacent same-style runs so the app renders fewer elements. */
+function merge(segments: readonly MdSegment[]): readonly MdSegment[] {
+  const merged: MdSegment[] = []
+  for (const segment of segments) {
+    const last = merged[merged.length - 1]
+    if (last !== undefined && last.style === segment.style) {
+      merged[merged.length - 1] = { text: last.text + segment.text, style: last.style }
+    } else {
+      merged.push({ ...segment })
+    }
+  }
+  return merged
+}
+
+/** One parsed inline run before wrapping. */
+interface InlineRun {
+  text: string
+  style: MdStyle
+}
+
+/**
+ * Parse inline markdown in one line of text. Link destinations render as a
+ * dim `(url)` suffix — the visible text keeps the accent.
+ */
+function parseInline(text: string): readonly InlineRun[] {
+  const runs: InlineRun[] = []
+  let rest = text
+  while (rest !== '') {
+    const code = /^`([^`]+)`/u.exec(rest)
+    if (code !== null) {
+      runs.push({ text: code[1] ?? '', style: 'code' })
+      rest = rest.slice(code[0].length)
+      continue
+    }
+    const boldItalic = /^\*\*\*([^*]+)\*\*\*/u.exec(rest)
+    if (boldItalic !== null) {
+      runs.push({ text: boldItalic[1] ?? '', style: 'boldItalic' })
+      rest = rest.slice(boldItalic[0].length)
+      continue
+    }
+    const bold = /^\*\*([^*]+)\*\*/u.exec(rest)
+    if (bold !== null) {
+      runs.push({ text: bold[1] ?? '', style: 'bold' })
+      rest = rest.slice(bold[0].length)
+      continue
+    }
+    const italic = /^\*([^*]+)\*/u.exec(rest) ?? /^_([^_]+)_/u.exec(rest)
+    if (italic !== null) {
+      runs.push({ text: italic[1] ?? '', style: 'italic' })
+      rest = rest.slice(italic[0].length)
+      continue
+    }
+    const strike = /^~~([^~]+)~~/u.exec(rest)
+    if (strike !== null) {
+      runs.push({ text: strike[1] ?? '', style: 'strike' })
+      rest = rest.slice(strike[0].length)
+      continue
+    }
+    const link = /^\[([^\]]+)\]\(([^)\s]+)\)/u.exec(rest)
+    if (link !== null) {
+      const label = link[1] ?? ''
+      const url = link[2] ?? ''
+      runs.push({ text: label, style: 'accent' })
+      runs.push({ text: ` (${url})`, style: 'dim' })
+      rest = rest.slice(link[0].length)
+      continue
+    }
+    // Plain run up to the next special opener.
+    const next = rest.search(/[*_`~[]/u)
+    if (next === -1) {
+      runs.push({ text: rest, style: 'plain' })
+      break
+    }
+    if (next > 0) {
+      runs.push({ text: rest.slice(0, next), style: 'plain' })
+      rest = rest.slice(next)
+      continue
+    }
+    // A special opener at position 0 that no pattern consumed: emit it
+    // literally and advance, so unbalanced syntax never loops.
+    runs.push({ text: rest.slice(0, 1), style: 'plain' })
+    rest = rest.slice(1)
+  }
+  return runs
+}
+
+const HEADING = /^(#{1,6})\s+(.*)$/u
+const FENCE = /^```([^\s`]*)\s*$/u
+const RULE = /^(?:---|\*\*\*|___)\s*$/u
+const QUOTE = /^>\s?(.*)$/u
+const UNORDERED = /^\s*[-*+]\s+(.*)$/u
+const ORDERED = /^\s*(\d+)[.)]\s+(.*)$/u
+
+/** Render markdown text into styled lines of at most `width` columns. */
+export function renderMarkdown(text: string, width: number): readonly MdLine[] {
+  const lines: MdLine[] = []
+  const push = (segments: readonly MdSegment[]): void => {
+    for (const wrapped of wrapSegments(segments, Math.max(10, width))) {
+      lines.push({ segments: merge(wrapped) })
+    }
+  }
+  const raw = text.replaceAll('\r', '')
+  const source = raw.split('\n')
+  let index = 0
+  while (index < source.length) {
+    const line = source[index] ?? ''
+    index += 1
+
+    // Fenced code block: verbatim lines in code style, language label first.
+    const fence = FENCE.exec(line)
+    if (fence !== null) {
+      const language = fence[1] ?? ''
+      if (language !== '') push([seg(`  ${language}`, 'dim')])
+      while (index < source.length && !FENCE.test(source[index] ?? '')) {
+        push([seg(`  ${source[index] ?? ''}`, 'code')])
+        index += 1
+      }
+      index += 1 // closing fence
+      continue
+    }
+
+    if (line.trim() === '') continue
+    if (RULE.test(line.trim())) {
+      push([seg(`  ${'─'.repeat(Math.max(1, Math.floor(width / 4)))}`, 'dim')])
+      continue
+    }
+    const heading = HEADING.exec(line)
+    if (heading !== null) {
+      push([seg(heading[2] ?? '', 'accent')])
+      continue
+    }
+    const quote = QUOTE.exec(line)
+    if (quote !== null) {
+      push([seg('  │ ', 'accent'), ...parseInline(quote[1] ?? '').map(run => seg(run.text, run.style === 'plain' ? 'dim' : run.style))])
+      continue
+    }
+    const ordered = ORDERED.exec(line)
+    if (ordered !== null) {
+      push([seg(`  ${ordered[1] ?? ''}. `, 'accent'), ...parseInline(ordered[2] ?? '').map(run => seg(run.text, run.style))])
+      continue
+    }
+    const unordered = UNORDERED.exec(line)
+    if (unordered !== null) {
+      push([seg('  • ', 'accent'), ...parseInline(unordered[1] ?? '').map(run => seg(run.text, run.style))])
+      continue
+    }
+
+    // Paragraph: gather until a blank line, then wrap as one flow. Line
+    // breaks inside a paragraph join as a single space (GFM soft breaks).
+    const paragraph = [line]
+    while (index < source.length && (source[index] ?? '').trim() !== '') {
+      paragraph.push(source[index] ?? '')
+      index += 1
+    }
+    const runs: InlineRun[] = []
+    for (let at = 0; at < paragraph.length; at += 1) {
+      if (at > 0) runs.push({ text: ' ', style: 'plain' })
+      runs.push(...parseInline(paragraph[at] ?? ''))
+    }
+    push(runs.map(run => seg(run.text, run.style)))
+  }
+  return lines
+}