dsh-code 0.1.0 → 0.3.0

package/src/render/projection.ts

@@ -8,13 +8,23 @@
  */
 
 import { boundContextSummary, type ContentBlock } from '@deepseek-ai/dsh-llm'
-import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session'
+// Type-only imports merge the plugin-owned SessionEventMap variants (command/*
+// 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. */
@@ -22,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. */
@@ -33,12 +45,29 @@ 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. */
   summary: string
 }
 
+/** One slash-command execution dispatched through `ctx.commands`. */
+export interface CommandEntry {
+  kind: 'command'
+  /** Pairing id shared with the matching `command/done`. */
+  commandId: string
+  /** Lowercase command name without the leading slash. */
+  name: string
+  /** Verbatim text following the command name. */
+  args: string
+  /** Execution state; `running` until the paired lifecycle event lands. */
+  state: 'running' | 'done' | 'error'
+  /** Handler outcome text, empty until it lands. */
+  summary: string
+}
+
 /** One turn-level failure surfaced from `turn/end`. */
 export interface ErrorEntry {
   kind: 'error'
@@ -47,7 +76,7 @@ export interface ErrorEntry {
 }
 
 /** Ordered transcript items the renderer draws. */
-export type TranscriptEntry = UserEntry | AssistantEntry | ToolEntry | ErrorEntry
+export type TranscriptEntry = UserEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry
 
 /** Cumulative token accounting folded from `assistant/message` usage reports. */
 export interface UsageTotals {
@@ -79,12 +108,25 @@ 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: SessionEvent<'todo/write'>['data']['todos']
+  todos: readonly TodoItem[]
   /** True while a durable turn is open (`turn/start` … `turn/end`). */
   busy: boolean
   /** Figures the status line renders. */
   stats: TranscriptStats
+  /**
+   * The `provider/model` pair of the last `request/header` snapshot — the
+   * session's own model record, which a resumed TUI prefers over the
+   * deployment default (mirrors the web host's resume selection order).
+   * 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
@@ -98,13 +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() },
   }
@@ -124,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)
@@ -146,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)),
@@ -168,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: '',
         }],
@@ -194,7 +256,15 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
     case 'todo/write':
       return { ...view, todos: event.data.todos }
     case 'turn/start':
-      return { ...view, busy: true, stats: { ...view.stats, turns: view.stats.turns + 1 } }
+      // The web todo projection clears on turn/start: a fresh turn's first
+      // write is the authoritative list, and a stale snapshot must not linger
+      // through a turn that has not written one yet.
+      return {
+        ...view,
+        busy: true,
+        todos: [],
+        stats: { ...view.stats, turns: view.stats.turns + 1 },
+      }
     case 'step/start':
       view.anchors.stepStart.set(`${event.data.turn}:${event.data.step}`, event.time)
       return { ...view, stats: { ...view.stats, steps: view.stats.steps + 1 } }
@@ -207,6 +277,43 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         entries: [...view.entries, { kind: 'error', text: `${reason.error.code}: ${reason.error.message}` }],
       }
     }
+    case 'request/header': {
+      // The session's own model record: the latest snapshot's provider/model
+      // pair, exactly what a resumed TUI restores as the selection.
+      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 {
+        ...view,
+        entries: [...view.entries, {
+          kind: 'command',
+          commandId: data.commandId,
+          name: data.name,
+          args: data.args ?? '',
+          state: 'running',
+          summary: '',
+        }],
+      }
+    }
+    case 'command/done': {
+      const data = event.data
+      const entries = view.entries.map((entry) => {
+        if (entry.kind !== 'command' || entry.commandId !== data.commandId) return entry
+        return {
+          ...entry,
+          state: data.kind === 'success' ? 'done' as const : 'error' as const,
+          summary: boundContextSummary(data.text ?? ''),
+        }
+      })
+      return { ...view, entries }
+    }
     default:
       return view
   }

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/text.ts

@@ -0,0 +1,24 @@
+/**
+ * Display-boundary sanitization for externally sourced text (model output,
+ * tool payloads, skill descriptions). Control characters — including ANSI
+ * CSI/OSC escape sequences — would otherwise pass through Ink into the
+ * terminal, letting output rewrite the screen or inject prompts. Newlines
+ * and tabs survive; everything else in C0/C1 plus DEL becomes a visible
+ * `\xNN` escape.
+ *
+ * @module @deepseek-ai/dsh-code/render/text
+ */
+
+/** C0 controls except tab (0x09) and newline (0x0a), plus DEL and C1. */
+const CONTROL_ESCAPE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu
+
+/**
+ * Escape control characters so externally sourced text cannot drive the
+ * terminal.
+ * @param text - raw text from a session event, tool payload, or catalog.
+ * @returns text with every control character (except `\n`, `\t`) rendered
+ * as a literal `\xNN` escape.
+ */
+export function displayText(text: string): string {
+  return text.replace(CONTROL_ESCAPE, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, '0')}`)
+}

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/skills.ts

@@ -0,0 +1,104 @@
+/**
+ * User-invocable skill watch for the `/` completion menu: the in-process
+ * equivalent of the web ui-skill trigger source. Skills are NOT commands —
+ * picking one lands the literal `/name ` text in the input, and submitting
+ * it as a normal prompt lets the host's tool-skill pre-step inject the body
+ * (the only entry point for model-disabled skills). Command descriptors win
+ * on a name collision; see the runner's dispatch.
+ *
+ * @module @deepseek-ai/dsh-code/skills
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import { isUserInvocable } from '@deepseek-ai/dsh-skill'
+import type { SkillSummary } from '@deepseek-ai/dsh-skill'
+
+/** One completion-menu row derived from a user-invocable skill. */
+export interface SkillRow {
+  /** Skill name; the literal `/name` text is what a pick lands. */
+  name: string
+  /** Human-readable description (suffixed when model-invocation is off). */
+  description: string
+  /** Whether the model may also invoke this skill by name. */
+  modelInvocable: boolean
+}
+
+/** The skill-catalog snapshot the completion menu subscribes to. */
+export interface SkillsView {
+  /** Name-sorted user-invocable rows; empty until the first load lands. */
+  readonly rows: readonly SkillRow[]
+  /** Subscribe to catalog changes; returns the unsubscribe function. */
+  subscribe(listener: () => void): () => void
+  /** Retarget the agent whose workspace the catalog is read for. */
+  setAgent(agent: Agent): void
+}
+
+/** Internal shape shared by {@link watchSkills} and its test doubles. */
+interface SkillsWatch extends SkillsView {
+  setAgent(agent: Agent): void
+}
+
+function toRows(skills: readonly SkillSummary[]): readonly SkillRow[] {
+  return skills
+    .filter(skill => isUserInvocable(skill))
+    .map(skill => ({
+      name: skill.name,
+      description: skill.description,
+      modelInvocable: skill.invocation.modelInvocable === true,
+    }))
+    .sort((left, right) => left.name < right.name ? -1 : 1)
+}
+
+/**
+ * Watch the user-invocable skill catalog for one agent's workspace. The first
+ * load starts when the owning agent is known (`setAgent`); `skills/change`
+ * and agent retargets re-read. Read failures keep the last good rows (the
+ * next change notification is the retry surface) — a missing `skills`
+ * service leaves the view permanently empty.
+ * @param ctx - context carrying the `skills` service (optional).
+ * @returns the view the completion menu subscribes to.
+ */
+export function watchSkills(ctx: Context): SkillsWatch {
+  const skills = ctx.get('skills')
+  let agent: Agent | undefined
+  let rows: readonly SkillRow[] = []
+  const listeners = new Set<() => void>()
+
+  const reload = (): void => {
+    if (skills === undefined || agent === undefined) return
+    skills.list({
+      cwd: agent.session.header.cwd,
+      scope: agent,
+    }).then((summaries: readonly SkillSummary[]) => {
+      const next = toRows(summaries)
+      if (next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name)) return
+      rows = next
+      for (const listener of listeners) listener()
+    }, () => {
+      // Discovery failure keeps the last good rows; the next skills/change
+      // notification is the retry surface (mirrors the web directory).
+    })
+  }
+
+  if (skills !== undefined) {
+    ctx.on('skills/change', reload)
+  }
+
+  const view: SkillsWatch = {
+    get rows(): readonly SkillRow[] {
+      return rows
+    },
+    subscribe(listener: () => void): () => void {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    setAgent(next: Agent): void {
+      agent = next
+      reload()
+    },
+  }
+  return view
+}

package/src/startup.ts

@@ -0,0 +1,91 @@
+/**
+ * The interactive terminal app's command-line provider: parses `--resume`,
+ * `--continue`, `--session`, and `--help`, then publishes
+ * {@link TUI_STARTUP_SERVICE} for the runner to consume lazily. Follows the
+ * headless bundle's startup shape (a commander action publishing a service
+ * through {@link parseCmdline}).
+ *
+ * Semantics:
+ * - `--resume <id|prefix>` — continue the persisted session whose id or unique
+ *   id-prefix matches; the TUI replays its transcript and appends to the same
+ *   durable log.
+ * - `--continue` / `-c` — resume the most recently modified persisted session
+ *   whose project directory matches the current working directory.
+ * - `--session <id>` — create a new session under an explicit identity (the
+ *   id must not exist yet).
+ * - no flags — a fresh session with a minted id.
+ *
+ * @module @deepseek-ai/dsh-tui/startup
+ */
+
+import { Command } from 'commander'
+import type { Context } from '@deepseek-ai/cordis'
+import { parseCmdline } from '@deepseek-ai/dsh-cmdline'
+
+/** Stable Cordis plugin name. */
+export const name = 'tui-startup'
+
+/** Services required before the invocation can be resolved. */
+export const inject = ['cmdlineArgs']
+
+/** Service provided by this plugin and injected by the terminal runner. */
+export const TUI_STARTUP_SERVICE = 'tuiStartup'
+
+/** How the runner obtains its session identity. */
+export type TuiStartup =
+  | { readonly kind: 'fresh' }
+  | { readonly kind: 'named'; readonly sessionId: string }
+  | { readonly kind: 'resume'; readonly sessionId: string }
+  | { readonly kind: 'latest' }
+
+/**
+ * This app's command: the launcher's flags this app owns, its description,
+ * and its help text.
+ * @returns a fresh program, so one process can parse more than once (tests).
+ */
+function tuiCommand(): Command {
+  return new Command()
+    .name('dsh --profile cli')
+    .description('Claude-Code-style interactive terminal for DeepSeek Harness.')
+    .helpOption('-h, --help', 'show this help')
+    .option('-r, --resume <session>', 'resume the persisted session with this id (or unique id prefix)')
+    .option('-c, --continue', 'resume the most recent persisted session for this working directory')
+    .option('--session <id>', 'create a new session under this explicit id')
+    .addHelpText('after', `
+Examples:
+  dsh --profile cli                       fresh session, minted id
+  dsh --profile cli --resume abc123       resume session by id prefix
+  dsh --profile cli --continue            resume the latest local session
+`)
+}
+
+/**
+ * Parse the invocation and publish the startup service. Mutual exclusions are
+ * usage errors rejected from the action before anything is provided.
+ * @param ctx - plugin context carrying the command line and exit request.
+ */
+export function apply(ctx: Context): void {
+  const program = tuiCommand()
+  program.action(() => {
+    const options = program.opts<{ resume?: string; continue?: boolean; session?: string }>()
+    const selected = [options.resume !== undefined, options.continue === true, options.session !== undefined]
+    if (selected.filter(Boolean).length > 1) {
+      program.error('error: --resume, --continue, and --session are mutually exclusive')
+    }
+    if (options.session !== undefined && options.session === '') {
+      program.error('error: --session needs an id')
+    }
+    if (options.resume !== undefined && options.resume === '') {
+      program.error('error: --resume needs a session id or id prefix')
+    }
+    const startup: TuiStartup = options.resume !== undefined
+      ? { kind: 'resume', sessionId: options.resume }
+      : options.continue === true
+        ? { kind: 'latest' }
+        : options.session !== undefined
+          ? { kind: 'named', sessionId: options.session }
+          : { kind: 'fresh' }
+    ctx.provide(TUI_STARTUP_SERVICE, { startup } satisfies { startup: TuiStartup })
+  })
+  parseCmdline(ctx, program)
+}

package/src/store.ts

@@ -8,7 +8,7 @@
  */
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
-import { createTranscriptView, projectEvent, type TranscriptView } from './render/projection.ts'
+import { createTranscriptView, projectEvent, projectEvents, type TranscriptView } from './render/projection.ts'
 
 /** The externally readable, event-fed transcript store for one session. */
 export interface TranscriptStore {
@@ -21,11 +21,17 @@ export interface TranscriptStore {
 }
 
 /**
- * Create one transcript store.
+ * Create one transcript store, optionally seeded with replayed history. The
+ * seed folds synchronously BEFORE the first render, so a resumed session
+ * paints its full transcript on mount (no live `session/event` fires for
+ * constructor seeds — the store's `session/event` feed only carries new
+ * appends).
+ * @param replay - persisted events in `seq` order (e.g. a resumed session's
+ * constructor seed); folded once and never re-notified.
  * @returns the store the runner feeds and the renderer subscribes to.
  */
-export function createTranscriptStore(): TranscriptStore {
-  let view = createTranscriptView()
+export function createTranscriptStore(replay?: readonly SessionEvent[]): TranscriptStore {
+  let view = replay === undefined ? createTranscriptView() : projectEvents(replay)
   const listeners = new Set<() => void>()
   return {
     getView: () => view,

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. */