dsh-code 1.0.5 → 1.0.7

package/src/render/editor.ts

@@ -487,12 +487,13 @@ export function composerMaxRows(terminalRows: number): number {
 }
 
 /**
- * History navigation starts with Up on an empty draft, or after visual
- * movement has reached the directional text edge of an unchanged recalled
- * entry. Every other position remains under textarea movement.
+ * History navigation starts with Up on an empty draft, or continues from an
+ * unchanged recalled entry whenever the caret sits on either text edge
+ * (start or end) - moving the caret into the interior returns the keys to
+ * ordinary editing until an edge is reached again.
  */
 export function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null, direction: -1 | 1): boolean {
   if (value === '') return direction < 0
   if (lastRecalled !== value) return false
-  return direction < 0 ? cursor === 0 : cursor === value.length
+  return cursor === 0 || cursor === value.length
 }

package/src/render/export.ts

@@ -7,7 +7,7 @@
  */
 
 import { assertNever } from '@deepseek-ai/dsh-util-values'
-import { imageLabels, type TranscriptView } from './projection.ts'
+import { fileLabels, imageLabels, type TranscriptView } from './projection.ts'
 
 /**
  * Render the transcript as a standalone markdown document.
@@ -15,6 +15,10 @@ import { imageLabels, type TranscriptView } from './projection.ts'
  * @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 === ''
@@ -23,13 +27,19 @@ export function buildExportMarkdown(view: TranscriptView, sessionId: string): st
     `> 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 {
-          out.push('## user', '', entry.text, ...(imageLabels(entry.images) === '' ? [] : [imageLabels(entry.images)]), '')
+          const attachments = attachmentLabels(entry)
+          out.push('## user', '', entry.text, ...(attachments === '' ? [] : [attachments]), '')
         }
         break
       case 'assistant':
@@ -68,7 +78,7 @@ export function buildExportMarkdown(view: TranscriptView, sessionId: string): st
         break
       case 'pending':
         // Codex PendingSteer: queued prompts export like ordinary user rows.
-        out.push('## user', '', entry.text, ...(imageLabels(entry.images) === '' ? [] : [imageLabels(entry.images)]), '')
+        out.push('## user', '', entry.text, ...(attachmentLabels(entry) === '' ? [] : [attachmentLabels(entry)]), '')
         break
       default:
         assertNever(entry, 'transcript entry kind')

package/src/render/fuzzy.ts

@@ -0,0 +1,83 @@
+/**
+ * Shared fuzzy ranking for `/` and `@` menu candidates: the query must be a
+ * case-insensitive ordered subsequence of the candidate name. Prefix hits
+ * rank first, then the strongest alignment score, then the source order of
+ * the input. Ported from the upstream web client's ui-primitives
+ * (rank-by-name.ts) so the terminal matches the web menu's discovery feel;
+ * the algorithm is unchanged, only the module's home moved.
+ *
+ * @module @deepseek-ai/dsh-code/render/fuzzy
+ */
+
+/** One match with its stable source position. */
+interface Ranked<T> {
+  readonly item: T
+  readonly index: number
+  readonly prefix: boolean
+  readonly score: number
+}
+
+/** Extra weight for name starts and separator boundaries. */
+function boundaryBonus(name: string, index: number): number {
+  return index === 0 || name.charAt(index - 1) === '-' || name.charAt(index - 1) === '_' ? 8 : 0
+}
+
+/**
+ * Score the strongest ordered-subsequence alignment in O(name × query).
+ * Boundary and adjacent matches earn weight; skipped and leading characters
+ * cost weight. Undefined when the query is not a subsequence of the name.
+ */
+function alignmentScore(name: string, query: string): number | undefined {
+  if (query.length > name.length) return undefined
+  const noMatch = Number.NEGATIVE_INFINITY
+  let previous = Array<number>(name.length).fill(noMatch)
+  for (let index = 0; index < name.length; index++) {
+    if (name.charAt(index) === query.charAt(0)) previous[index] = 1 + boundaryBonus(name, index) - index
+  }
+  for (let queryIndex = 1; queryIndex < query.length; queryIndex++) {
+    const current = Array<number>(name.length).fill(noMatch)
+    // Sweep the previous row once: `left` is its score one character back
+    // (the adjacent continuation), `leftLeft` two back (the earliest gapped one).
+    let left = noMatch
+    let leftLeft = noMatch
+    let bestGapped = noMatch
+    for (const [index, prior] of previous.entries()) {
+      if (leftLeft !== noMatch) bestGapped = Math.max(bestGapped, leftLeft + index - 2)
+      if (name.charAt(index) === query.charAt(queryIndex)) {
+        const bonus = 1 + boundaryBonus(name, index)
+        let score = noMatch
+        if (left !== noMatch) score = left + bonus + 4
+        if (bestGapped !== noMatch) score = Math.max(score, bestGapped + bonus + 1 - index)
+        current[index] = score
+      }
+      leftLeft = left
+      left = prior
+    }
+    previous = current
+  }
+  let best = noMatch
+  for (const score of previous) best = Math.max(best, score)
+  return best === noMatch ? undefined : best
+}
+
+/**
+ * Rank named items by a menu query.
+ * @param items - candidates in source order (the caller's composition order
+ * is the final tie-breaker, e.g. local commands before registry entries).
+ * @param rawQuery - the text typed after the trigger, matched case-insensitively.
+ * @returns the matching items: prefix hits first, then by alignment score,
+ * then in source order. The input list itself for an empty query.
+ */
+export function rankByName<T extends { readonly name: string }>(items: readonly T[], rawQuery: string): readonly T[] {
+  const query = rawQuery.toLowerCase()
+  if (query === '') return items
+  const ranked: Ranked<T>[] = []
+  items.forEach((item, index) => {
+    const name = item.name.toLowerCase()
+    const score = alignmentScore(name, query)
+    if (score !== undefined) ranked.push({ item, index, prefix: name.startsWith(query), score })
+  })
+  ranked.sort((left, right) =>
+    Number(right.prefix) - Number(left.prefix) || right.score - left.score || left.index - right.index)
+  return ranked.map(match => match.item)
+}

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