dsh-code 0.8.0 → 0.9.1

package/src/session-directory.ts

@@ -1,6 +1,7 @@
 /** Lightweight session-directory projection for the /resume picker. */
 
-import { basename, resolve } from 'node:path'
+import { basename, dirname, resolve } from 'node:path'
+import { realpathSync } from 'node:fs'
 import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session'
 
 export interface SessionRecord {
@@ -42,6 +43,8 @@ export interface SessionDirectoryOptions {
 export interface SessionRow {
   readonly id: string
   readonly createdAt: number
+  /** Last-activity timestamp: artifact mtime when known, else createdAt. */
+  readonly updatedAt: number
   readonly cwd: string
   readonly workspace: string
   readonly parent?: string
@@ -63,7 +66,16 @@ export function isSubagentSession(header: SessionHeader): boolean {
 
 function comparablePath(value: string): string {
   const resolved = resolve(value)
-  return CASE_INSENSITIVE_FS ? resolved.toLowerCase() : resolved
+  // Codex's paths_match_after_normalization pattern: canonicalize through the
+  // filesystem when the path exists (resolving symlinks, subst drives, and
+  // junctions that plain `resolve` keeps distinct), falling back to lexical
+  // resolution when the directory no longer does.
+  const fold = (path: string): string => CASE_INSENSITIVE_FS ? path.toLowerCase() : path
+  try {
+    return fold(realpathSync(resolved))
+  } catch {
+    return fold(resolved)
+  }
 }
 
 /** Platform-consistent path equality for session cwd comparisons. */
@@ -98,8 +110,20 @@ export function newestRootForCwd(headers: readonly SessionHeader[], cwd: string)
   return local[0]
 }
 
-/** Filter/sort header-only records. No session log is loaded here. */
-export function projectSessionRows(records: readonly SessionRecord[], options: SessionDirectoryOptions): SessionRow[] {
+/**
+ * Filter/sort header-only records. No session log is loaded here. Sorting is
+ * by LAST ACTIVITY (`updated` — artifact mtime when the caller resolved one,
+ * else createdAt), matching the codex resume picker's default UpdatedAt
+ * ordering: a session you kept talking in outranks one created later but idle.
+ * @param records - the header-only records.
+ * @param options - filter/sort options.
+ * @param updated - per-session last-activity timestamps, when resolved.
+ */
+export function projectSessionRows(
+  records: readonly SessionRecord[],
+  options: SessionDirectoryOptions,
+  updated?: ReadonlyMap<string, number>,
+): SessionRow[] {
   const needle = options.query.trim().toLowerCase()
   return records
     .filter(record => options.sessions === 'all' || !isSubagentSession(record.header))
@@ -107,9 +131,13 @@ export function projectSessionRows(records: readonly SessionRecord[], options: S
     .map(record => {
       const cwd = record.header.cwd ?? ''
       const subagent = isSubagentSession(record.header)
+      const activity = updated?.get(record.header.id)
       return {
         id: record.header.id,
         createdAt: record.header.createdAt,
+        updatedAt: activity === undefined || !Number.isFinite(activity) || activity < record.header.createdAt
+          ? record.header.createdAt
+          : activity,
         cwd,
         workspace: cwd === '' ? '(no workspace)' : basename(cwd),
         parent: record.header.parentSession,
@@ -122,8 +150,8 @@ export function projectSessionRows(records: readonly SessionRecord[], options: S
     })
     .filter(row => needle === '' || `${row.id} ${row.cwd} ${row.workspace} ${row.preset}`.toLowerCase().includes(needle))
     .sort((left, right) => options.sort === 'newest'
-      ? right.createdAt - left.createdAt
-      : left.createdAt - right.createdAt)
+      ? right.updatedAt - left.updatedAt || right.createdAt - left.createdAt
+      : left.updatedAt - right.updatedAt || left.createdAt - right.createdAt)
 }
 
 /** Merge page-local title observations without disturbing directory order. */
@@ -139,3 +167,97 @@ export function mergeSessionTitles(
   }
   return rows.map(row => titles.has(row.id) ? { ...row, title: titles.get(row.id) } : row)
 }
+
+/**
+ * Encode a session id the way the JSONL backend does for its on-disk layout
+ * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used ONLY to
+ * validate that a `locate()` path really is this session's directory before
+ * any deletion touches the filesystem — a local copy of the pure upstream
+ * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+ */
+export function encodeSessionSegment(raw: string): string {
+  if (raw.length === 0) throw new Error('cannot encode an empty path segment')
+  if (raw === '.') return '~002E'
+  if (raw === '..') return '~002E~002E'
+  let out = ''
+  for (let i = 0; i < raw.length; i += 1) {
+    const code = raw.charCodeAt(i)
+    const ch = String.fromCharCode(code)
+    if (ch !== '~' && /^[A-Za-z0-9._-]$/u.test(ch)) {
+      out += ch
+    } else {
+      out += `~${code.toString(16).toUpperCase().padStart(4, '0')}`
+    }
+  }
+  return out
+}
+
+/** The session-log artifact names the JSONL backend may create. */
+export const SESSION_ARTIFACT_NAMES: readonly string[] = ['session.jsonl', 'session.jsonl.zstd']
+
+/**
+ * Guard one `locate()` artifact path before deletion (codex's scoped-path
+ * check, adapted to the JSONL layout): the file must be a `session.jsonl`
+ * artifact sitting in the directory named exactly `encodeSegment(id)`.
+ * @param artifact - the path the persistence backend located.
+ * @param id - the session id the artifact claims to belong to.
+ * @returns the owning session directory, or undefined when the layout is unexpected.
+ */
+export function sessionArtifactDirectory(artifact: string, id: string): string | undefined {
+  if (basename(artifact) !== 'session.jsonl' && basename(artifact) !== 'session.jsonl.zstd') return undefined
+  const dir = dirname(artifact)
+  if (basename(dir) !== encodeSessionSegment(id)) return undefined
+  return dir
+}
+
+/**
+ * Collect one session's deletion subtree: the id plus every record whose
+ * parent chain leads to it (codex deletes subagent threads with their root).
+ * @param records - the full directory listing.
+ * @param id - the root session id to delete.
+ * @returns the ids to delete, root first.
+ */
+export function collectDeletionSubtree(records: readonly SessionRecord[], id: string): string[] {
+  const parentOf = new Map<string, string | undefined>()
+  for (const record of records) parentOf.set(record.header.id, record.header.parentSession)
+  const doomed = new Set<string>([id])
+  // Iterate to a fixed point: children may be listed before their parents.
+  for (let pass = 0; pass < 2; pass += 1) {
+    for (const candidate of parentOf.keys()) {
+      if (doomed.has(candidate)) continue
+      let ancestor = parentOf.get(candidate)
+      let depth = 0
+      while (ancestor !== undefined && depth < 64) {
+        if (doomed.has(ancestor)) {
+          doomed.add(candidate)
+          break
+        }
+        ancestor = parentOf.get(ancestor)
+        depth += 1
+      }
+    }
+  }
+  return [...doomed]
+}
+
+/**
+ * Codex-style relative time for session rows ("now", "5m ago", "3h ago",
+ * "2d ago"; older than a week falls back to the local date).
+ * @param timestamp - epoch milliseconds of the last activity.
+ * @param now - the pinned reference clock (one value per list render).
+ */
+export function formatRelativeTime(timestamp: number, now: number): string {
+  const seconds = Math.round((now - timestamp) / 1000)
+  if (seconds < 0) return 'now'
+  if (seconds < 60) return 'now'
+  const minutes = Math.round(seconds / 60)
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.round(minutes / 60)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.round(hours / 24)
+  if (days < 7) return `${days}d ago`
+  const date = new Date(timestamp)
+  const month = `${date.getMonth() + 1}`.padStart(2, '0')
+  const day = `${date.getDate()}`.padStart(2, '0')
+  return `${date.getFullYear()}-${month}-${day}`
+}

package/src/subagents.ts

@@ -0,0 +1,165 @@
+/**
+ * Live subagent activity feed: a bounded, display-only projection of CHILD
+ * session events. The transcript store folds only the root session (the
+ * durable truth this TUI renders); subagent conversations are their own
+ * sessions, and before this module their events were dropped entirely —
+ * a running subagent was invisible until its parent tool call settled.
+ *
+ * This is NOT a second transcript: each child folds to ONE row (label,
+ * running state, bounded last-activity text), capped at
+ * {@link MAX_SUBAGENT_ROWS}. Rows are advisory display state, rebuilt from
+ * live events; nothing here persists or replays. Notification is coalesced
+ * to one microtask per delivery burst, mirroring the transcript store's
+ * contract (per-token synchronous notify once cascaded past React's nested
+ * update limit on the GLM thinking path).
+ *
+ * @module @deepseek-ai/dsh-code/subagents
+ */
+
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+
+/** Hard row cap: a fan-out larger than this stays summarized by the head. */
+export const MAX_SUBAGENT_ROWS = 8
+
+/** Bounded last-activity text (plain characters, display-sliced later). */
+const MAX_ACTIVITY_CHARS = 80
+
+/** One live subagent row in the feed. */
+export interface SubagentRow {
+  /** Child session id. */
+  readonly id: string
+  /** Display label (session title when observed, else a short id form). */
+  readonly label: string
+  /** Coarse lifecycle state folded from the child's events. */
+  readonly state: 'running' | 'idle' | 'done'
+  /** Bounded last-activity text for the status line. */
+  readonly activity: string
+  /** Last fold time (ms, event clock) — newest-first ordering key. */
+  readonly updatedAt: number
+}
+
+/** The read-only snapshot surface the renderer subscribes to. */
+export interface SubagentFeedView {
+  /** Subscribe to feed changes; returns the unsubscribe function. */
+  subscribe(listener: () => void): () => void
+  /** Read the current rows (identity-stable between changes). */
+  getSnapshot(): readonly SubagentRow[]
+}
+
+/** Single-line bounded preview of an assembled message's text content. */
+function messagePreview(content: unknown): string {
+  if (!Array.isArray(content)) return 'replied'
+  const texts: string[] = []
+  for (const block of content) {
+    if (texts.join(' ').length >= MAX_ACTIVITY_CHARS) break
+    if (typeof block === 'object' && block !== null) {
+      const { type, text } = block as Record<string, unknown>
+      if (type === 'text' && typeof text === 'string' && text !== '') texts.push(text)
+    }
+  }
+  const joined = texts.join(' ').replace(/\s+/gu, ' ').trim()
+  return joined === '' ? 'replied' : bound(joined)
+}
+
+/** Bound one activity string to the display budget. */
+function bound(text: string): string {
+  const flat = text.replace(/\s+/gu, ' ').trim()
+  return flat.length > MAX_ACTIVITY_CHARS ? `${flat.slice(0, MAX_ACTIVITY_CHARS - 1)}…` : flat
+}
+
+/**
+ * Fold one child-session event into its feed row (pure).
+ * Unknown event kinds leave the row untouched.
+ * @param previous - the row's current state, when any.
+ * @param sessionId - the child session id.
+ * @param event - the child session event.
+ * @returns the next row state.
+ */
+export function foldSubagentRow(previous: SubagentRow | undefined, sessionId: string, event: SessionEvent): SubagentRow {
+  const base: SubagentRow = previous ?? {
+    id: sessionId,
+    label: `agent ${sessionId.slice(-6)}`,
+    state: 'running',
+    activity: 'starting…',
+    updatedAt: event.time,
+  }
+  const data = event.data as Record<string, unknown>
+  switch (event.type) {
+    case 'session/title': {
+      const title = data['title']
+      const text = typeof title === 'string' && title.trim() !== '' ? title : undefined
+      return text === undefined || text === base.label ? base : { ...base, label: bound(text), updatedAt: event.time }
+    }
+    case 'request/header':
+      return { ...base, state: 'running', activity: 'working…', updatedAt: event.time }
+    case 'user/message':
+      return { ...base, state: 'running', activity: 'prompted', updatedAt: event.time }
+    case 'assistant/chunk':
+      return { ...base, state: 'running', activity: 'thinking…', updatedAt: event.time }
+    case 'assistant/message':
+      return { ...base, state: 'idle', activity: messagePreview(data['message'] === undefined ? undefined : (data['message'] as { content?: unknown }).content), updatedAt: event.time }
+    case 'tool/call': {
+      const name = typeof data['name'] === 'string' ? data['name'] : 'tool'
+      return { ...base, state: 'running', activity: `tool ${name}`, updatedAt: event.time }
+    }
+    case 'tool/result':
+      return { ...base, state: 'running', activity: 'tool done', updatedAt: event.time }
+    case 'turn/start':
+      return { ...base, state: 'running', activity: base.activity === 'starting…' ? 'working…' : base.activity, updatedAt: event.time }
+    case 'turn/end':
+      return { ...base, state: 'done', activity: 'finished', updatedAt: event.time }
+    default:
+      // Unknown kinds leave the row untouched (identity-stable: a no-op
+      // fold must not churn the snapshot array).
+      return base
+  }
+}
+
+/**
+ * Create one subagent feed. `apply` folds a child event (the caller gates
+ * which sessions are children); `reset` clears on a session switch. Row
+ * order is first-seen; the snapshot array is frozen and only replaced when
+ * a row actually changed.
+ * @returns the mutable feed handle plus its `SubagentFeedView`.
+ */
+export function createSubagentFeed(): SubagentFeedView & {
+  apply(sessionId: string, event: SessionEvent): void
+  reset(): void
+} {
+  let rows: readonly SubagentRow[] = Object.freeze([])
+  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 {
+    apply(sessionId: string, event: SessionEvent): void {
+      const index = rows.findIndex(row => row.id === sessionId)
+      const previous = index === -1 ? undefined : rows[index]
+      const next = foldSubagentRow(previous, sessionId, event)
+      if (next === previous) return
+      if (index === -1 && rows.length >= MAX_SUBAGENT_ROWS) return
+      rows = Object.freeze(index === -1 ? [...rows, next] : rows.map((row, at) => at === index ? next : row))
+      notify()
+    },
+    reset(): void {
+      if (rows.length === 0) return
+      rows = Object.freeze([])
+      notify()
+    },
+    subscribe(listener: () => void): () => void {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    getSnapshot(): readonly SubagentRow[] {
+      return rows
+    },
+  }
+}