dsh-code 0.3.0 → 0.4.0

package/src/index.ts

@@ -12,6 +12,7 @@
 
 import { randomUUID } from 'node:crypto'
 import { readFileSync } from 'node:fs'
+import { writeFile as writeFileAsync } from 'node:fs/promises'
 import { basename, join } from 'node:path'
 import { createElement } from 'react'
 import type { Context } from '@deepseek-ai/cordis'
@@ -22,6 +23,8 @@ import type {} from '@deepseek-ai/dsh-agent-default-model'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { SessionId, type Session, type SessionEvent, type SessionHeader, type UserMessage } from '@deepseek-ai/dsh-session'
 import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence'
+// Type-only: carries the ctx.sessionTitle service merge for /title.
+import type {} from '@deepseek-ai/dsh-session-title'
 // Empty type imports carry the loader Context merge for the settlement await
 // and the cmdline Context merge for the appExit host value.
 import type {} from '@deepseek-ai/cordis-plugin-loader'
@@ -36,6 +39,7 @@ import { mountQuestionProvider, type QuestionStore } from './questions.ts'
 import { createTranscriptStore } from './store.ts'
 import { watchSkills, type SkillsView } from './skills.ts'
 import { toolArgumentsPreview } from './render/tool-preview.ts'
+import { buildExportMarkdown } from './render/export.ts'
 import type { TuiStartup } from './startup.ts'
 
 /** Stable Cordis plugin name. */
@@ -405,6 +409,46 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     return `${row.provider}/${row.model}`
   }
 
+  /**
+   * Export the folded transcript to a markdown file (/export). The default
+   * target sits beside the session's cwd so the file lands in the user's
+   * workspace; an absolute or cwd-relative argument overrides it.
+   */
+  const exportTranscript = async (argument: string): Promise<void> => {
+    const wanted = argument.trim()
+    const defaultName = `dsh-session-${session.id.slice(-8)}.md`
+    const target = wanted === ''
+      ? join(cwd, defaultName)
+      : /^[a-zA-Z]:[\\/]/u.test(wanted) || wanted.startsWith('/')
+        ? wanted
+        : join(cwd, wanted)
+    const markdown = buildExportMarkdown(store.getView(), session.id)
+    try {
+      await writeFileAsync(target, `${markdown}\n`, 'utf8')
+      bridge.notify(`exported to ${target}`)
+    } catch (error: unknown) {
+      bridge.notify(`export failed: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  /**
+   * Rename the session (/title): a user title pins the session and stops
+   * automatic generation (the service's own contract). The appended
+   * `session/title` event flows back through the store into the status line.
+   */
+  const renameTitle = (argument: string): string => {
+    const title = argument.trim()
+    if (title === '') return 'usage: /title <text>'
+    const service = ctx.get('sessionTitle')
+    if (service === undefined) return 'session titles are unavailable in this profile'
+    try {
+      service.rename(session, title)
+      return `title → ${title}`
+    } catch (error: unknown) {
+      return `rename failed: ${error instanceof Error ? error.message : String(error)}`
+    }
+  }
+
   const initialModel = store.getView().model !== ''
     ? store.getView().model
     : `${defaults.provider}/${defaults.model}`
@@ -428,6 +472,8 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     loadMentions: mentions.candidates,
     cyclePermission,
     selectModel,
+    exportTranscript,
+    renameTitle,
     onBridgeReady: (instance: AppBridge) => {
       bridge.notify = instance.notify
     },

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