fix review findings: polish ask-user question

packages/ui/stdio-agent/src/stdio-chat.ts

@@ -23,6 +23,8 @@ import { AgentId } from '@deepseek-ai/dsh-agent'
 import {
   UserInteractionError,
   type AskUserQuestionAnswer,
+  type AskUserQuestionAnswerItem,
+  type AskUserQuestionItem,
   type AskUserQuestionOption,
   type AskUserQuestionRequest,
 } from '@deepseek-ai/dsh-user-interaction'
@@ -63,27 +65,20 @@ function isTTYPair(input: Readable, output: Writable): boolean {
   return Boolean((input as { isTTY?: boolean }).isTTY && (output as { isTTY?: boolean }).isTTY)
 }
 
-function optionAnswer(option: AskUserQuestionOption): string {
-  return option.value ?? option.label
-}
-
-function displayOptions(options: AskUserQuestionOption[] = []): AskUserQuestionOption[] {
-  return options
-    .map((option, index) => ({ option, index }))
-    .sort((left, right) => {
-      if (left.option.recommended === right.option.recommended) return left.index - right.index
-      return left.option.recommended ? -1 : 1
-    })
-    .map(({ option }) => option)
-}
-
 interface PendingQuestion {
   request: AskUserQuestionRequest
+  questionIndex: number
+  answers: AskUserQuestionAnswerItem[]
   resolve(answer: AskUserQuestionAnswer): void
   reject(error: unknown): void
   onAbort: () => void
 }
 
+type OptionSelection =
+  | { kind: 'selected'; options: AskUserQuestionOption[] }
+  | { kind: 'custom' }
+  | { kind: 'invalid' }
+
 /**
  * The plugin body, parameterized over its I/O runtime. `apply` is the thin
  * production wrapper that binds the real `process` streams; tests call this
@@ -205,12 +200,16 @@ export function createStdioChat(ctx: Context, config: Config, runtime: StdioRunt
       if (status === 'idle') maybeExit()
     })
 
+    const activeQuestionItem = (pending: PendingQuestion): AskUserQuestionItem =>
+      pending.request.questions[pending.questionIndex] as AskUserQuestionItem
+
     const renderQuestion = (pending: PendingQuestion): void => {
-      const { request } = pending
+      const question = activeQuestionItem(pending)
+      const options = question.options ?? []
       output.write('\n')
-      output.write(request.header ? `[${request.header}] ${request.question}\n` : `[question] ${request.question}\n`)
-      displayOptions(request.options).forEach((option, index) => {
-        output.write(`  ${index + 1}. ${option.label}${option.recommended ? ' (recommended)' : ''}\n`)
+      output.write(question.header ? `[${question.header}] ${question.question}\n` : `${question.question}\n`)
+      options.forEach((option, index) => {
+        output.write(`  ${index + 1}. ${option.label}\n`)
         if (option.description) output.write(`     ${option.description}\n`)
       })
       output.write('> ')
@@ -249,41 +248,64 @@ export function createStdioChat(ctx: Context, config: Config, runtime: StdioRunt
       }
     }
 
-    const finishQuestion = (pending: PendingQuestion, answer: AskUserQuestionAnswer): void => {
-      removeAbortListener(pending)
+    const finishQuestion = (pending: PendingQuestion): void => {
       activeQuestion = undefined
-      pending.resolve(answer)
+      removeAbortListener(pending)
+      pending.resolve({ answers: pending.answers })
       output.write('\n')
       startNextQuestion()
     }
 
+    const answerCurrentQuestion = (pending: PendingQuestion, answer: AskUserQuestionAnswerItem): void => {
+      pending.answers.push(answer)
+      pending.questionIndex += 1
+      if (pending.questionIndex >= pending.request.questions.length) {
+        finishQuestion(pending)
+        return
+      }
+      renderQuestion(pending)
+    }
+
+    const selectedOptions = (text: string, options: AskUserQuestionOption[], multiSelect: boolean): OptionSelection => {
+      if (text === '') return { kind: 'invalid' }
+      if (!multiSelect) {
+        if (!/^\d+$/.test(text)) return { kind: 'custom' }
+        const selected = options[Number(text) - 1]
+        return selected === undefined ? { kind: 'invalid' } : { kind: 'selected', options: [selected] }
+      }
+      const indices = text.split(/[,\s]+/).filter(Boolean)
+      if (indices.length === 0) return { kind: 'invalid' }
+      if (indices.some(part => !/^\d+$/.test(part))) return { kind: 'custom' }
+      const uniqueIndices = [...new Set(indices)]
+      const selected = uniqueIndices.map(part => options[Number(part) - 1])
+      return selected.some(option => option === undefined)
+        ? { kind: 'invalid' }
+        : { kind: 'selected', options: selected as AskUserQuestionOption[] }
+    }
+
     const answerQuestion = (line: string): void => {
       const pending = activeQuestion as PendingQuestion
+      const question = activeQuestionItem(pending)
 
       const text = line.trim()
-      const options = displayOptions(pending.request.options)
-      const selectedIndex = /^\d+$/.test(text) ? Number(text) - 1 : -1
-      const selected = selectedIndex >= 0 ? options[selectedIndex] : undefined
-      if (selected !== undefined) {
-        finishQuestion(pending, { answer: optionAnswer(selected), option: selected })
+      const options = question.options ?? []
+      const selection = options.length > 0
+        ? selectedOptions(text, options, question.multiSelect ?? false)
+        : { kind: text === '' ? 'invalid' : 'custom' } as OptionSelection
+      if (selection.kind === 'selected') {
+        answerCurrentQuestion(pending, { id: question.id, selected: selection.options.map(option => option.label) })
         return
       }
 
-      const recommended = options.find(option => option.recommended)
-      if (text === '' && recommended !== undefined) {
-        finishQuestion(pending, { answer: optionAnswer(recommended), option: recommended })
-        return
-      }
-
-      const allowCustom = options.length === 0 || (pending.request.allowCustom ?? true)
-      if (allowCustom && text !== '') {
-        finishQuestion(pending, { answer: text })
+      if (selection.kind === 'custom' && text !== '') {
+        answerCurrentQuestion(pending, { id: question.id, selected: [], custom: text })
         return
       }
 
       output.write(options.length > 0
         ? 'Please enter one of the option numbers'
-          + (allowCustom ? ' or a custom answer' : '')
+          + (question.multiSelect ? ' (comma or space separated)' : '')
+          + ' or a custom answer'
           + '.\n> '
         : 'Please enter an answer.\n> ')
     }
@@ -298,6 +320,8 @@ export function createStdioChat(ctx: Context, config: Config, runtime: StdioRunt
         return new Promise<AskUserQuestionAnswer>((resolve, reject) => {
           const pending: PendingQuestion = {
             request,
+            questionIndex: 0,
+            answers: [],
             resolve,
             reject,
             onAbort: () => {

packages/ui/stdio-agent/tests/stdio-chat.spec.ts

@@ -1,4 +1,4 @@
-import { Readable } from 'node:stream'
+import { Readable, Writable } from 'node:stream'
 import { describe, expect, it, vi } from 'vitest'
 import { Context } from 'cordis'
 import type { Agent, AgentStatus } from '@deepseek-ai/dsh-agent'
@@ -107,6 +107,30 @@ describe('createStdioChat rendering', () => {
     // And it drives the default agent id 'main'.
   })
 
+  it('detects readline terminal mode from both stream TTY flags', async () => {
+    for (const [inputTTY, outputTTY] of [[true, false], [true, true]] as const) {
+      const ctx = new Context()
+      await ctx.plugin(AgentRegistry)
+      await ctx.plugin(UserInteractionService)
+      let text = ''
+      const output = new Writable({
+        write(chunk, _encoding, callback) {
+          text += String(chunk)
+          callback()
+        },
+      }) as Writable & { isTTY?: boolean }
+      const { runtime } = makeRuntime({ output })
+      ;(runtime.input as Readable & { isTTY?: boolean }).isTTY = inputTTY
+      output.isTTY = outputTTY
+      const fiber = await ctx.plugin(Object.assign((inner: Context) => {
+        createStdioChat(inner, CONFIG, runtime)
+      }, { inject: ['agents', 'userInteraction'] }))
+
+      expect(text).toContain('hi there')
+      await fiber.dispose()
+    }
+  })
+
   it('renders text-delta chunks verbatim', async () => {
     const { ctx, out } = await setup()
     ctx.emit('session/event', makeSession('main'), chunkEvent({ type: 'text-delta', index: 0, text: 'hello' }))
@@ -273,150 +297,229 @@ describe('createStdioChat input', () => {
     ctx.agents.register(agent)
 
     const answer = ctx.userInteraction.ask({
-      header: 'Confirm',
-      question: 'Proceed with the edit?',
-      options: [{ label: 'Yes', value: 'Proceed', description: 'Apply the edit now.', recommended: true }],
+      questions: [{
+        id: 'confirm',
+        header: 'Confirm',
+        question: 'Proceed with the edit?',
+        options: [{ label: 'Yes', description: 'Apply the edit now.' }],
+      }],
     })
     await new Promise(r => setImmediate(r))
     input.feed('Use a smaller change')
 
-    await expect(answer).resolves.toEqual({ answer: 'Use a smaller change' })
+    await expect(answer).resolves.toEqual({ answers: [{ id: 'confirm', selected: [], custom: 'Use a smaller change' }] })
     expect(agent.sent).toEqual([])
     expect(out.text()).toContain('[Confirm] Proceed with the edit?')
-    expect(out.text()).toContain('1. Yes (recommended)')
+    expect(out.text()).toContain('1. Yes')
     expect(out.text()).toContain('Apply the edit now.')
   })
 
   it('answers a pending user question by numeric option selection', async () => {
     const { ctx, input } = await setup()
     const answer = ctx.userInteraction.ask({
-      question: 'Which mode?',
-      options: [
-        { label: 'Safe', value: 'Use safe mode', recommended: true },
-        { label: 'Fast', value: 'Use fast mode' },
-      ],
-      allowCustom: false,
+      questions: [{
+        id: 'mode',
+        question: 'Which mode?',
+        options: [
+          { label: 'Safe' },
+          { label: 'Fast' },
+        ],
+      }],
     })
     await new Promise(r => setImmediate(r))
     input.feed('2')
 
     await expect(answer).resolves.toEqual({
-      answer: 'Use fast mode',
-      option: { label: 'Fast', value: 'Use fast mode' },
+      answers: [{ id: 'mode', selected: ['Fast'] }],
     })
   })
 
-  it('renders recommended options first and selects by displayed number', async () => {
+  it('renders options in input order and selects by displayed number', async () => {
     const { ctx, input, out } = await setup()
     const answer = ctx.userInteraction.ask({
-      question: 'Which topic?',
-      options: [
-        { label: 'Hobbies', value: 'hobbies' },
-        { label: 'Work', value: 'work', description: 'Questions about current projects.' },
-        { label: 'Casual', value: 'casual', recommended: true, description: 'Easy conversation.' },
-      ],
-      allowCustom: false,
+      questions: [{
+        id: 'topic',
+        question: 'Which topic?',
+        options: [
+          { label: 'Hobbies' },
+          { label: 'Work', description: 'Questions about current projects.' },
+          { label: 'Casual', description: 'Easy conversation.' },
+        ],
+      }],
     })
     await new Promise(r => setImmediate(r))
 
     expect(out.text()).toContain([
-      '[question] Which topic?',
-      '  1. Casual (recommended)',
-      '     Easy conversation.',
-      '  2. Hobbies',
-      '  3. Work',
+      'Which topic?',
+      '  1. Hobbies',
+      '  2. Work',
       '     Questions about current projects.',
+      '  3. Casual',
+      '     Easy conversation.',
     ].join('\n'))
-    input.feed('1')
+    input.feed('3')
 
     await expect(answer).resolves.toEqual({
-      answer: 'casual',
-      option: { label: 'Casual', value: 'casual', recommended: true, description: 'Easy conversation.' },
+      answers: [{ id: 'topic', selected: ['Casual'] }],
     })
   })
 
-  it('uses the recommended option when the user submits an empty answer', async () => {
+  it('answers a multi-select question with multiple numeric selections', async () => {
     const { ctx, input } = await setup()
     const answer = ctx.userInteraction.ask({
-      question: 'Continue?',
-      options: [
-        { label: 'No' },
-        { label: 'Yes', value: 'Continue', recommended: true },
-      ],
-      allowCustom: false,
+      questions: [{
+        id: 'targets',
+        question: 'What should I update?',
+        options: [{ label: 'Tests' }, { label: 'Docs' }, { label: 'Code' }],
+        multiSelect: true,
+      }],
     })
     await new Promise(r => setImmediate(r))
-    input.feed('')
+    input.feed('1 1, 3')
 
     await expect(answer).resolves.toEqual({
-      answer: 'Continue',
-      option: { label: 'Yes', value: 'Continue', recommended: true },
+      answers: [{ id: 'targets', selected: ['Tests', 'Code'] }],
     })
   })
 
-  it('re-prompts when options are required and the input is invalid', async () => {
-    const { ctx, input, out } = await setup()
+  it('accepts non-numeric multi-select input as a custom answer', async () => {
+    const { ctx, input } = await setup()
     const answer = ctx.userInteraction.ask({
-      question: 'Which mode?',
-      options: [{ label: 'Safe' }],
-      allowCustom: false,
+      questions: [{
+        id: 'targets',
+        question: 'What should I update?',
+        options: [{ label: 'Tests' }, { label: 'Docs' }],
+        multiSelect: true,
+      }],
     })
     await new Promise(r => setImmediate(r))
-    input.feed('custom')
+    input.feed('the release notes')
+
+    await expect(answer).resolves.toEqual({
+      answers: [{ id: 'targets', selected: [], custom: 'the release notes' }],
+    })
+  })
+
+  it('asks every question in a batch and returns answers by id', async () => {
+    const { ctx, input, out } = await setup()
+    const answer = ctx.userInteraction.ask({
+      questions: [
+        { id: 'language', question: 'Which language?', options: [{ label: 'Python' }, { label: 'TypeScript' }] },
+        { id: 'note', question: 'Any note?' },
+      ],
+    })
     await new Promise(r => setImmediate(r))
-    expect(out.text()).toContain('Please enter one of the option numbers.')
+    input.feed('2')
+    await new Promise(r => setImmediate(r))
+    expect(out.text()).toContain('\nAny note?\n')
+    input.feed('ship today')
+
+    await expect(answer).resolves.toEqual({
+      answers: [
+        { id: 'language', selected: ['TypeScript'] },
+        { id: 'note', selected: [], custom: 'ship today' },
+      ],
+    })
+  })
+
+  it('re-prompts when option input is invalid', async () => {
+    const { ctx, input, out } = await setup()
+    const answer = ctx.userInteraction.ask({
+      questions: [{
+        id: 'mode',
+        question: 'Which mode?',
+        options: [{ label: 'Safe' }],
+        multiSelect: true,
+      }],
+    })
+    await new Promise(r => setImmediate(r))
+    input.feed('2')
+    await new Promise(r => setImmediate(r))
+    expect(out.text()).toContain('Please enter one of the option numbers (comma or space separated) or a custom answer.')
     input.feed('1')
 
     await expect(answer).resolves.toEqual({
-      answer: 'Safe',
-      option: { label: 'Safe' },
+      answers: [{ id: 'mode', selected: ['Safe'] }],
     })
   })
 
-  it('re-prompts with custom-answer guidance when options also allow free-form input', async () => {
+  it('re-prompts when single-select option input is out of range', async () => {
     const { ctx, input, out } = await setup()
     const answer = ctx.userInteraction.ask({
-      question: 'Which mode?',
-      options: [{ label: 'Safe' }],
+      questions: [{
+        id: 'mode',
+        question: 'Which mode?',
+        options: [{ label: 'Safe' }],
+      }],
+    })
+    await new Promise(r => setImmediate(r))
+    input.feed('2')
+    await new Promise(r => setImmediate(r))
+    expect(out.text()).toContain('Please enter one of the option numbers or a custom answer.')
+    input.feed('1')
+
+    await expect(answer).resolves.toEqual({
+      answers: [{ id: 'mode', selected: ['Safe'] }],
+    })
+  })
+
+  it('re-prompts when multi-select input contains no option numbers', async () => {
+    const { ctx, input, out } = await setup()
+    const answer = ctx.userInteraction.ask({
+      questions: [{
+        id: 'mode',
+        question: 'Which mode?',
+        options: [{ label: 'Safe' }],
+        multiSelect: true,
+      }],
+    })
+    await new Promise(r => setImmediate(r))
+    input.feed(',')
+    await new Promise(r => setImmediate(r))
+    expect(out.text()).toContain('Please enter one of the option numbers (comma or space separated) or a custom answer.')
+    input.feed('1')
+
+    await expect(answer).resolves.toEqual({
+      answers: [{ id: 'mode', selected: ['Safe'] }],
+    })
+  })
+
+  it('re-prompts when an option question receives an empty answer', async () => {
+    const { ctx, input, out } = await setup()
+    const answer = ctx.userInteraction.ask({
+      questions: [{
+        id: 'mode',
+        question: 'Which mode?',
+        options: [{ label: 'Safe' }],
+      }],
     })
     await new Promise(r => setImmediate(r))
     input.feed('')
     await new Promise(r => setImmediate(r))
     expect(out.text()).toContain('Please enter one of the option numbers or a custom answer.')
-    input.feed('Use custom mode')
+    input.feed('1')
 
-    await expect(answer).resolves.toEqual({ answer: 'Use custom mode' })
+    await expect(answer).resolves.toEqual({
+      answers: [{ id: 'mode', selected: ['Safe'] }],
+    })
   })
 
-  it('re-prompts when a free-form question receives an empty answer', async () => {
+  it('re-prompts when a question receives an empty answer', async () => {
     const { ctx, input, out } = await setup()
-    const answer = ctx.userInteraction.ask({ question: 'What should I use?' })
+    const answer = ctx.userInteraction.ask({ questions: [{ id: 'path', question: 'What should I use?' }] })
     await new Promise(r => setImmediate(r))
     input.feed('')
     await new Promise(r => setImmediate(r))
     expect(out.text()).toContain('Please enter an answer.')
     input.feed('Use defaults')
 
-    await expect(answer).resolves.toEqual({ answer: 'Use defaults' })
-  })
-
-  it('accepts free-form input for an optionless question even when allowCustom is false', async () => {
-    const { ctx, input } = await setup()
-    const answer = ctx.userInteraction.ask({
-      question: 'Choose?',
-      allowCustom: false,
-    })
-    await new Promise(r => setImmediate(r))
-
-    input.feed('Use the default path')
-
-    await expect(answer).resolves.toEqual({ answer: 'Use the default path' })
+    await expect(answer).resolves.toEqual({ answers: [{ id: 'path', selected: [], custom: 'Use defaults' }] })
   })
 
   it('rejects an active question when its signal aborts', async () => {
     const { ctx } = await setup()
     const controller = new AbortController()
-    const answer = ctx.userInteraction.ask({ question: 'Continue?', signal: controller.signal })
+    const answer = ctx.userInteraction.ask({ questions: [{ id: 'continue', question: 'Continue?' }], signal: controller.signal })
     const rejected = expect(answer).rejects.toMatchObject({ code: 'ASK_ABORTED' })
     await new Promise(r => setImmediate(r))
 
@@ -428,40 +531,40 @@ describe('createStdioChat input', () => {
   it('continues to the next queued question when the active question aborts', async () => {
     const { ctx, input, out } = await setup()
     const controller = new AbortController()
-    const first = ctx.userInteraction.ask({ question: 'First?', signal: controller.signal })
+    const first = ctx.userInteraction.ask({ questions: [{ id: 'first', question: 'First?' }], signal: controller.signal })
     const firstRejected = expect(first).rejects.toMatchObject({ code: 'ASK_ABORTED' })
-    const second = ctx.userInteraction.ask({ question: 'Second?' })
+    const second = ctx.userInteraction.ask({ questions: [{ id: 'second', question: 'Second?' }] })
     await new Promise(r => setImmediate(r))
 
     controller.abort()
     await firstRejected
     await new Promise(r => setImmediate(r))
-    expect(out.text()).toContain('[question] Second?')
+    expect(out.text()).toContain('\nSecond?\n')
     input.feed('second answer')
 
-    await expect(second).resolves.toEqual({ answer: 'second answer' })
+    await expect(second).resolves.toEqual({ answers: [{ id: 'second', selected: [], custom: 'second answer' }] })
   })
 
   it('skips a queued question whose signal aborted before it became active', async () => {
     const { ctx, input, out } = await setup()
     const controller = new AbortController()
-    const first = ctx.userInteraction.ask({ question: 'First?' })
-    const second = ctx.userInteraction.ask({ question: 'Second?', signal: controller.signal })
+    const first = ctx.userInteraction.ask({ questions: [{ id: 'first', question: 'First?' }] })
+    const second = ctx.userInteraction.ask({ questions: [{ id: 'second', question: 'Second?' }], signal: controller.signal })
     const secondRejected = expect(second).rejects.toMatchObject({ code: 'ASK_ABORTED' })
     await new Promise(r => setImmediate(r))
 
     controller.abort()
     input.feed('first answer')
 
-    await expect(first).resolves.toEqual({ answer: 'first answer' })
+    await expect(first).resolves.toEqual({ answers: [{ id: 'first', selected: [], custom: 'first answer' }] })
     await secondRejected
-    expect(out.text()).not.toContain('[question] Second?')
+    expect(out.text()).not.toContain('\nSecond?\n')
   })
 
   it('rejects active and queued questions when the UI is disposed', async () => {
     const { ctx, fiber } = await setup()
-    const active = ctx.userInteraction.ask({ question: 'Active?' })
-    const queued = ctx.userInteraction.ask({ question: 'Queued?' })
+    const active = ctx.userInteraction.ask({ questions: [{ id: 'active', question: 'Active?' }] })
+    const queued = ctx.userInteraction.ask({ questions: [{ id: 'queued', question: 'Queued?' }] })
     const activeRejected = expect(active).rejects.toMatchObject({ code: 'ASK_ABORTED' })
     const queuedRejected = expect(queued).rejects.toMatchObject({ code: 'ASK_ABORTED' })
     await new Promise(r => setImmediate(r))
@@ -474,8 +577,8 @@ describe('createStdioChat input', () => {
 
   it('rejects active and queued questions when stdin closes before the user answers', async () => {
     const { ctx, input, exit } = await setup()
-    const active = ctx.userInteraction.ask({ question: 'Active?' })
-    const queued = ctx.userInteraction.ask({ question: 'Queued?' })
+    const active = ctx.userInteraction.ask({ questions: [{ id: 'active', question: 'Active?' }] })
+    const queued = ctx.userInteraction.ask({ questions: [{ id: 'queued', question: 'Queued?' }] })
     const activeRejected = expect(active).rejects.toMatchObject({ code: 'ASK_ABORTED' })
     const queuedRejected = expect(queued).rejects.toMatchObject({ code: 'ASK_ABORTED' })
     await new Promise(r => setImmediate(r))
@@ -494,7 +597,7 @@ describe('createStdioChat input', () => {
     await new Promise(r => setImmediate(r))
     const before = out.text()
 
-    const answer = ctx.userInteraction.ask({ question: 'Too late?' })
+    const answer = ctx.userInteraction.ask({ questions: [{ id: 'late', question: 'Too late?' }] })
 
     await expect(answer).rejects.toMatchObject({ code: 'ASK_ABORTED' })
     expect(out.text()).toBe(before)