dsh-code 0.2.0 → 0.3.0

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
+}

package/src/render/projection.ts

@@ -10,14 +10,21 @@
 import { boundContextSummary, type ContentBlock } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session'
 // Type-only imports merge the plugin-owned SessionEventMap variants (command/*
-// from dsh-commands) into the union this reducer switches on.
+// from dsh-commands, plan/mode, permission/preset) into the union this reducer
+// switches on.
 import type {} from '@deepseek-ai/dsh-commands'
+import type {} from '@deepseek-ai/dsh-plan-mode'
+import type {} from '@deepseek-ai/dsh-permission-presets'
+import { toolArgumentsPreview } from './tool-preview.ts'
 
 /** One user prompt line. */
 export interface UserEntry {
   kind: 'user'
   /** Joined text blocks of the user message. */
   text: string
+  /** True for collapsed injected context (plugin/continuation notices), which
+   * the renderer marks with a dim ↳ instead of the user ❯ prompt. */
+  notice: boolean
 }
 
 /** One assembled assistant reply. */
@@ -25,6 +32,8 @@ export interface AssistantEntry {
   kind: 'assistant'
   /** Joined text blocks of the assistant message. */
   text: string
+  /** Joined reasoning blocks of the same message, empty when the model thought out loud. */
+  reasoning: string
 }
 
 /** One model-requested tool invocation and its settled state. */
@@ -36,6 +45,8 @@ export interface ToolEntry {
   name: string
   /** Raw arguments JSON string exactly as the model produced it. */
   arguments: string
+  /** Bounded human-meaningful arguments preview for the tool card. */
+  preview: string
   /** Execution state; `running` until the paired result lands. */
   state: 'running' | 'done' | 'error'
   /** Bounded first text block of the result, empty until it lands. */
@@ -97,6 +108,8 @@ export interface TranscriptView {
   entries: readonly TranscriptEntry[]
   /** Text accumulated from `assistant/chunk` deltas since the last flush. */
   streaming: string
+  /** Thinking accumulated from `assistant/chunk` reasoning deltas since the last flush. */
+  streamingReasoning: string
   /** Latest whole-list todo snapshot from `todo/write`, empty when none. */
   todos: readonly TodoItem[]
   /** True while a durable turn is open (`turn/start` … `turn/end`). */
@@ -110,6 +123,10 @@ export interface TranscriptView {
    * Empty before the session's first request.
    */
   model: string
+  /** Plan mode state folded from the last `plan/mode` event. */
+  plan: boolean
+  /** Active permission preset folded from the last `permission/preset` event, empty before one. */
+  permission: string
   /**
    * Fold-internal timing anchors, never rendered: open step and tool-call
    * start timestamps the next `assistant/message` / `tool/result` resolves
@@ -123,14 +140,22 @@ function textOf(content: readonly ContentBlock[]): string {
   return content.filter(block => block.type === 'text').map(block => block.text).join('')
 }
 
+/** Join the reasoning blocks of a content list; non-reasoning blocks contribute nothing. */
+function reasoningOf(content: readonly ContentBlock[]): string {
+  return content.filter(block => block.type === 'reasoning').map(block => block.text).join('')
+}
+
 /** A fresh, empty transcript view. */
 export function createTranscriptView(): TranscriptView {
   return {
     entries: [],
     streaming: '',
+    streamingReasoning: '',
     todos: [],
     busy: false,
     model: '',
+    plan: false,
+    permission: '',
     stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 } },
     anchors: { stepStart: new Map(), toolStart: new Map() },
   }
@@ -150,20 +175,25 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       // elsewhere in the product; only direct human prompts render in full.
       const message = event.data
       if (message.source.kind === 'user') {
-        return { ...view, entries: [...view.entries, { kind: 'user', text: textOf(message.content) }] }
+        return { ...view, entries: [...view.entries, { kind: 'user', text: textOf(message.content), notice: false }] }
       }
       const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
         ? message.source.summary
         : message.source.kind
-      return { ...view, entries: [...view.entries, { kind: 'user', text: boundContextSummary(notice) }] }
+      return { ...view, entries: [...view.entries, { kind: 'user', text: boundContextSummary(notice), notice: true }] }
     }
     case 'assistant/chunk': {
       const chunk = event.data.chunk
-      if (chunk.type !== 'text-delta') return view
-      return { ...view, streaming: view.streaming + chunk.text }
+      if (chunk.type === 'text-delta') {
+        return { ...view, streaming: view.streaming + chunk.text }
+      }
+      if (chunk.type === 'reasoning-delta') {
+        return { ...view, streamingReasoning: view.streamingReasoning + chunk.text }
+      }
+      return view
     }
     case 'assistant/message': {
-      // The assembled message is authoritative; drop the streamed buffer.
+      // The assembled message is authoritative; drop the streamed buffers.
       const key = `${event.data.turn}:${event.data.step}`
       const started = view.anchors.stepStart.get(key)
       view.anchors.stepStart.delete(key)
@@ -172,7 +202,12 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       return {
         ...view,
         streaming: '',
-        entries: [...view.entries, { kind: 'assistant', text: textOf(event.data.message.content) }],
+        streamingReasoning: '',
+        entries: [...view.entries, {
+          kind: 'assistant',
+          text: textOf(event.data.message.content),
+          reasoning: reasoningOf(event.data.message.content),
+        }],
         stats: {
           ...view.stats,
           llmMs: view.stats.llmMs + (started === undefined ? 0 : Math.max(0, event.time - started)),
@@ -194,6 +229,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           callId: data.callId,
           name: data.name,
           arguments: data.arguments,
+          preview: toolArgumentsPreview(data.arguments, data.name),
           state: 'running',
           summary: '',
         }],
@@ -247,6 +283,11 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       const config = event.data.header.config
       return { ...view, model: `${config.provider}/${config.model}` }
     }
+    case 'plan/mode':
+      // Whole-value replace; the last one wins (upstream fold semantics).
+      return { ...view, plan: event.data.active }
+    case 'permission/preset':
+      return { ...view, permission: event.data.preset }
     case 'command/run': {
       const data = event.data
       return {

package/src/render/status.ts

@@ -57,6 +57,10 @@ export interface StatusFacts {
   branch: string
   /** Short session identifier (last dash-separated segment or tail). */
   sessionId: string
+  /** Whether plan mode is active (folded from `plan/mode`). */
+  plan: boolean
+  /** Active permission preset (folded from `permission/preset`), empty when unknown. */
+  permission: string
 }
 
 /**
@@ -67,8 +71,12 @@ export interface StatusFacts {
  */
 export function buildStatusGroups(facts: StatusFacts, stats: TranscriptStats): string[] {
   const groups: string[] = []
-  const identity = [facts.model, facts.cwd, facts.branch === '' ? undefined : `⑂ ${facts.branch}`]
-    .filter(part => part !== undefined && part !== '')
+  const identity = [
+    facts.model,
+    facts.cwd,
+    facts.branch === '' ? undefined : `⑂ ${facts.branch}`,
+    facts.plan ? '⧉ plan' : undefined,
+  ].filter(part => part !== undefined && part !== '')
   if (identity.length > 0) groups.push(identity.join(' · '))
   if (stats.turns > 0 || stats.steps > 0) {
     groups.push(`T${stats.turns} · S${stats.steps}`)
@@ -83,5 +91,9 @@ export function buildStatusGroups(facts: StatusFacts, stats: TranscriptStats): s
     groups.push(`↑${formatTokens(stats.usage.inputTokens)} ↓${formatTokens(stats.usage.outputTokens)}`)
   }
   if (facts.sessionId !== '') groups.push(facts.sessionId)
+  // The permission preset trails the line: switching it changes only the
+  // tail, so the left-aligned bar never shifts its other groups. Plain text,
+  // the Claude-Code permission-mode display (no glyphs).
+  if (facts.permission !== undefined && facts.permission !== '') groups.push(facts.permission)
   return groups
 }

package/src/render/tool-preview.ts

@@ -0,0 +1,34 @@
+/**
+ * Bounded preview line for a tool invocation's raw JSON arguments: the first
+ * human-meaningful string among the well-known keys (command, path, query, …)
+ * with a fallback to the bounded raw JSON. Shared by the tool card in the
+ * transcript and the approval bar's command preview.
+ *
+ * @module @deepseek-ai/dsh-code/render/tool-preview
+ */
+
+/** Keys searched in declaration order when building a preview. */
+const PREVIEW_KEYS = ['command', 'cmd', 'description', 'path', 'pattern', 'query'] as const
+
+/**
+ * Resolve one bounded preview for raw tool arguments.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @param toolName - the tool the arguments belong to (fallback label).
+ * @returns the preview line; empty when nothing useful resolves.
+ */
+export function toolArgumentsPreview(args: string, toolName: string): string {
+  if (args === '') return toolName
+  try {
+    const parsed: unknown = JSON.parse(args)
+    if (parsed !== null && typeof parsed === 'object') {
+      const record = parsed as Record<string, unknown>
+      for (const key of PREVIEW_KEYS) {
+        const value = record[key]
+        if (typeof value === 'string' && value !== '') return value
+      }
+    }
+  } catch {
+    // Raw JSON parse failed: fall through to the bounded raw arguments.
+  }
+  return args.length > 80 ? `${args.slice(0, 77)}...` : args
+}

package/src/theme.ts

@@ -28,6 +28,10 @@ export const TUI_RGB = {
   error: [239, 68, 68],
   /** Warning amber — `--dsw-static-amber-500`. */
   warn: [245, 158, 11],
+  /** Default foreground text — `--dsw-static-neutral-50`. */
+  text: [236, 240, 246],
+  /** Inline/fenced code — soft sky blue, distinct from brand accents. */
+  code: [125, 211, 252],
 } as const satisfies Record<string, readonly [number, number, number]>
 
 /** Paint with the primary brand blue: whale, wordmark, tool names, accents. */