dsh-code 0.7.0 → 0.8.0

package/src/render/tool-preview.ts

@@ -2,7 +2,10 @@
  * 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.
+ * transcript and the approval bar's command preview. Arguments longer than
+ * {@link MAX_PARSE_CHARS} are never parsed: the preview is a display concern,
+ * and a synchronous `JSON.parse` plus string copies of an unbounded model
+ * payload must not run on the approval or projection paths.
  *
  * @module @deepseek-ai/dsh-code/render/tool-preview
  */
@@ -10,6 +13,18 @@
 /** Keys searched in declaration order when building a preview. */
 const PREVIEW_KEYS = ['command', 'cmd', 'description', 'path', 'pattern', 'query'] as const
 
+/**
+ * Raw arguments longer than this are skipped without parsing and fall back
+ * to the bounded raw preview. Well above any realistic command/path/query
+ * string while keeping the synchronous parse cost negligible.
+ */
+const MAX_PARSE_CHARS = 4096
+
+/** Bounded raw-arguments fallback shared by the skip-parse and parse-failure paths. */
+function boundedRawPreview(args: string): string {
+  return args.length > 80 ? `${args.slice(0, 77)}...` : args
+}
+
 /**
  * Resolve one bounded preview for raw tool arguments.
  * @param args - raw JSON arguments string as the model produced it.
@@ -18,6 +33,7 @@ const PREVIEW_KEYS = ['command', 'cmd', 'description', 'path', 'pattern', 'query
  */
 export function toolArgumentsPreview(args: string, toolName: string): string {
   if (args === '') return toolName
+  if (args.length > MAX_PARSE_CHARS) return boundedRawPreview(args)
   try {
     const parsed: unknown = JSON.parse(args)
     if (parsed !== null && typeof parsed === 'object') {
@@ -30,5 +46,5 @@ export function toolArgumentsPreview(args: string, toolName: string): string {
   } catch {
     // Raw JSON parse failed: fall through to the bounded raw arguments.
   }
-  return args.length > 80 ? `${args.slice(0, 77)}...` : args
+  return boundedRawPreview(args)
 }

package/src/session-directory.ts

@@ -53,21 +53,60 @@ export interface SessionRow {
   readonly title?: string
 }
 
-function samePath(left: string | undefined, right: string): boolean {
+/** Case-insensitive filesystems (Windows, macOS) compare paths by lowercased form. */
+const CASE_INSENSITIVE_FS = process.platform === 'win32' || process.platform === 'darwin'
+
+/** True when the header describes a subagent conversation (durable lineage). */
+export function isSubagentSession(header: SessionHeader): boolean {
+  return header.origin === 'subagent' || header.parentSession !== undefined
+}
+
+function comparablePath(value: string): string {
+  const resolved = resolve(value)
+  return CASE_INSENSITIVE_FS ? resolved.toLowerCase() : resolved
+}
+
+/** Platform-consistent path equality for session cwd comparisons. */
+export function samePath(left: string | undefined, right: string): boolean {
   if (left === undefined) return false
-  return resolve(left).toLowerCase() === resolve(right).toLowerCase()
+  return comparablePath(left) === comparablePath(right)
+}
+
+/**
+ * Unique header match by exact id or unique id prefix (root and subagent
+ * headers alike); the caller applies any lineage gate.
+ * @param headers - the persisted headers.
+ * @param wanted - the id or id prefix.
+ * @returns the uniquely matched header.
+ * @throws when nothing matches or the prefix is ambiguous.
+ */
+export function matchSessionId(headers: readonly SessionHeader[], wanted: string): SessionHeader {
+  const exact = headers.filter(header => header.id === wanted)
+  const matches = exact.length > 0 ? exact : headers.filter(header => header.id.startsWith(wanted))
+  if (matches.length === 0) throw new Error(`no persisted session matches "${wanted}"`)
+  if (matches.length > 1) {
+    throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches): use more of the id`)
+  }
+  return matches[0]!
+}
+
+/** The newest persisted ROOT session pinned to this cwd, or undefined. */
+export function newestRootForCwd(headers: readonly SessionHeader[], cwd: string): SessionHeader | undefined {
+  const local = headers
+    .filter(header => !isSubagentSession(header) && samePath(header.cwd, cwd))
+    .sort((left, right) => right.createdAt - left.createdAt)
+  return local[0]
 }
 
 /** Filter/sort header-only records. No session log is loaded here. */
 export function projectSessionRows(records: readonly SessionRecord[], options: SessionDirectoryOptions): SessionRow[] {
   const needle = options.query.trim().toLowerCase()
   return records
-    .filter(record => options.sessions === 'all'
-      || (record.header.parentSession === undefined && record.header.origin !== 'subagent'))
+    .filter(record => options.sessions === 'all' || !isSubagentSession(record.header))
     .filter(record => options.cwd === 'all' || samePath(record.header.cwd, options.currentCwd))
     .map(record => {
       const cwd = record.header.cwd ?? ''
-      const subagent = record.header.origin === 'subagent' || record.header.parentSession !== undefined
+      const subagent = isSubagentSession(record.header)
       return {
         id: record.header.id,
         createdAt: record.header.createdAt,

package/src/skills.ts

@@ -69,12 +69,15 @@ export function watchSkills(ctx: Context): SkillsWatch {
   const listeners = new Set<() => void>()
 
   const reload = (): void => {
-    const currentAgent = agent
-    if (skills === undefined || currentAgent === undefined) return
+    const target = agent
+    if (skills === undefined || target === undefined) return
     Promise.resolve().then(() => skills.list({
-      cwd: currentAgent.session.header.cwd,
-      scope: currentAgent,
+      cwd: target.session.header.cwd,
+      scope: target,
     })).then((summaries: readonly SkillSummary[]) => {
+      // A retarget landed while this catalog was loading: the rows belong to
+      // another agent's workspace and must never overwrite the current view.
+      if (agent !== target) return
       const next = toRows(summaries)
       const unchanged = next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name)
       rows = next
@@ -83,6 +86,7 @@ export function watchSkills(ctx: Context): SkillsWatch {
       if (unchanged && !recovered) return
       for (const listener of listeners) listener()
     }).catch((cause: unknown) => {
+      if (agent !== target) return
       // Discovery failure keeps the last good rows; the next skills/change
       // notification is the retry surface (mirrors the web directory).
       rows = [...rows]

package/src/store.ts

@@ -1,8 +1,19 @@
 /**
  * Observable transcript store: folds session events into the projection view
  * and notifies subscribers. The renderer subscribes through
- * `useSyncExternalStore`; the runner owns event feeding. The store owns no
- * timing — listeners fire synchronously after each applied event.
+ * `useSyncExternalStore`; the runner owns event feeding.
+ *
+ * Notification coalescing: the fold stays synchronous — `getView()` always
+ * returns the latest state the moment `apply` returns — but listener
+ * notification is scheduled on a microtask and deduplicated, so N events
+ * delivered inside one synchronous drain (the zai/GLM adapter drains its
+ * token buffer in sub-millisecond bursts) produce ONE React re-render.
+ * Synchronous per-event notification instead cascades one
+ * `useSyncExternalStore` force-update per token inside a single flush; the
+ * reconciler counts those as nested passive updates and floods React's
+ * "Maximum update depth exceeded" warning past 50 events, besides rendering
+ * the whole live tree once per token. A microtask keeps latency within the
+ * same macrotask, before Ink's throttled paint.
  *
  * @module @deepseek-ai/dsh-tui/store
  */
@@ -35,6 +46,17 @@ export interface TranscriptStore {
 export function createTranscriptStore(replay?: readonly SessionEvent[]): TranscriptStore {
   let view = replay === undefined ? createTranscriptView() : projectEvents(replay)
   const listeners = new Set<() => void>()
+  let scheduled = false
+  const notify = (): void => {
+    if (scheduled) return
+    scheduled = true
+    queueMicrotask(() => {
+      scheduled = false
+      for (const listener of listeners) {
+        listener()
+      }
+    })
+  }
   return {
     getView: () => view,
     subscribe(listener: () => void): () => void {
@@ -47,15 +69,11 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
       const next = projectEvent(view, event)
       if (next === view) return
       view = next
-      for (const listener of listeners) {
-        listener()
-      }
+      notify()
     },
     reset(): void {
       view = createTranscriptView()
-      for (const listener of listeners) {
-        listener()
-      }
+      notify()
     },
   }
 }

package/src/version.ts

@@ -0,0 +1,16 @@
+/** Installed dsh-code version exposed by the terminal header. */
+
+import { readFileSync } from 'node:fs'
+
+/** Read one package manifest version without making terminal startup depend on it. */
+export function readPackageVersion(manifest = new URL('../package.json', import.meta.url)): string {
+  try {
+    const parsed = JSON.parse(readFileSync(manifest, 'utf8')) as { version?: unknown }
+    return typeof parsed.version === 'string' && parsed.version.length > 0 ? parsed.version : '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}
+
+/** Version of the installed dsh-code package. */
+export const DSH_CODE_VERSION = readPackageVersion()