dsh-code 0.4.0 → 0.5.0

package/src/session-switch.ts

@@ -0,0 +1,58 @@
+/** Latest-wins, idle-bound queue for safe Agent session changes. */
+
+export interface IdleActivity {
+  readonly status: 'idle' | 'running'
+  whenIdle(): Promise<void>
+}
+
+interface Request<T> {
+  readonly activity: IdleActivity
+  readonly value: T
+}
+
+export class SessionSwitchQueue<T> {
+  private pending: Request<T> | undefined
+  private pumping = false
+
+  constructor(
+    private readonly execute: (value: T) => Promise<void>,
+    private readonly failed: (error: unknown) => void,
+  ) {}
+
+  /** Queue a request; a later request replaces any request still waiting. */
+  request(activity: IdleActivity, value: T): 'queued' | 'started' {
+    this.pending = { activity, value }
+    const outcome = activity.status === 'running' || this.pumping ? 'queued' : 'started'
+    if (!this.pumping) void this.pump()
+    return outcome
+  }
+
+  /** Cancel only work that has not begun activation. */
+  cancel(): boolean {
+    if (this.pending === undefined) return false
+    this.pending = undefined
+    return true
+  }
+
+  private async pump(): Promise<void> {
+    this.pumping = true
+    try {
+      while (this.pending !== undefined) {
+        const observed = this.pending
+        await observed.activity.whenIdle()
+        // Another request replaced this one while the turn was converging.
+        if (this.pending !== observed) continue
+        this.pending = undefined
+        try {
+          await this.execute(observed.value)
+        } catch (error: unknown) {
+          this.failed(error)
+        }
+      }
+    } finally {
+      this.pumping = false
+      // A request may land between the loop condition and finally.
+      if (this.pending !== undefined) void this.pump()
+    }
+  }
+}

package/src/skills.ts

@@ -28,6 +28,8 @@ export interface SkillRow {
 export interface SkillsView {
   /** Name-sorted user-invocable rows; empty until the first load lands. */
   readonly rows: readonly SkillRow[]
+  /** Latest catalog-read failure; the help panel exposes it in place. */
+  readonly error?: string
   /** Subscribe to catalog changes; returns the unsubscribe function. */
   subscribe(listener: () => void): () => void
   /** Retarget the agent whose workspace the catalog is read for. */
@@ -63,21 +65,29 @@ export function watchSkills(ctx: Context): SkillsWatch {
   const skills = ctx.get('skills')
   let agent: Agent | undefined
   let rows: readonly SkillRow[] = []
+  let error: string | undefined
   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 currentAgent = agent
+    if (skills === undefined || currentAgent === undefined) return
+    Promise.resolve().then(() => skills.list({
+      cwd: currentAgent.session.header.cwd,
+      scope: currentAgent,
+    })).then((summaries: readonly SkillSummary[]) => {
       const next = toRows(summaries)
-      if (next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name)) return
+      const unchanged = next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name)
       rows = next
+      const recovered = error !== undefined
+      error = undefined
+      if (unchanged && !recovered) return
       for (const listener of listeners) listener()
-    }, () => {
+    }).catch((cause: unknown) => {
       // Discovery failure keeps the last good rows; the next skills/change
       // notification is the retry surface (mirrors the web directory).
+      rows = [...rows]
+      error = cause instanceof Error ? cause.message : String(cause)
+      for (const listener of listeners) listener()
     })
   }
 
@@ -89,6 +99,9 @@ export function watchSkills(ctx: Context): SkillsWatch {
     get rows(): readonly SkillRow[] {
       return rows
     },
+    get error(): string | undefined {
+      return error
+    },
     subscribe(listener: () => void): () => void {
       listeners.add(listener)
       return () => {

package/src/startup.ts

@@ -1,6 +1,6 @@
 /**
  * The interactive terminal app's command-line provider: parses `--resume`,
- * `--continue`, `--session`, and `--help`, then publishes
+ * `--continue`, `--session`, `--mode`, 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}).
@@ -33,11 +33,37 @@ 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: 'fresh'; readonly mode?: string }
+  | { readonly kind: 'named'; readonly sessionId: string; readonly mode?: string }
   | { readonly kind: 'resume'; readonly sessionId: string }
   | { readonly kind: 'latest' }
 
+export interface TuiStartupOptions {
+  readonly resume?: string
+  readonly continue?: boolean
+  readonly session?: string
+  readonly mode?: string
+}
+
+/** Pure option policy shared by Commander and tests. */
+export function resolveTuiStartup(options: TuiStartupOptions): TuiStartup {
+  const selected = [options.resume !== undefined, options.continue === true, options.session !== undefined]
+  if (selected.filter(Boolean).length > 1) throw new Error('--resume, --continue, and --session are mutually exclusive')
+  if (options.session === '') throw new Error('--session needs an id')
+  if (options.resume === '') throw new Error('--resume needs a session id or id prefix')
+  if (options.mode === '') throw new Error('--mode needs a preset id')
+  if (options.mode !== undefined && (options.resume !== undefined || options.continue === true)) {
+    throw new Error('--mode applies only to a new session; it cannot be combined with --resume or --continue')
+  }
+  return options.resume !== undefined
+    ? { kind: 'resume', sessionId: options.resume }
+    : options.continue === true
+      ? { kind: 'latest' }
+      : options.session !== undefined
+        ? { kind: 'named', sessionId: options.session, ...options.mode === undefined ? {} : { mode: options.mode } }
+        : { kind: 'fresh', ...options.mode === undefined ? {} : { mode: options.mode } }
+}
+
 /**
  * This app's command: the launcher's flags this app owns, its description,
  * and its help text.
@@ -51,11 +77,13 @@ function tuiCommand(): Command {
     .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')
+    .option('--mode <preset>', 'agent preset for a newly created session')
     .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
+  dsh --profile cli --mode minimal        fresh session using the minimal preset
 `)
 }
 
@@ -67,24 +95,14 @@ Examples:
 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 options = program.opts<TuiStartupOptions>()
+    let startup: TuiStartup | undefined
+    try {
+      startup = resolveTuiStartup(options)
+    } catch (error: unknown) {
+      program.error(`error: ${error instanceof Error ? error.message : String(error)}`)
     }
-    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' }
+    if (startup === undefined) return
     ctx.provide(TUI_STARTUP_SERVICE, { startup } satisfies { startup: TuiStartup })
   })
   parseCmdline(ctx, program)