decide

1import { atom, read, update } from 'claude-code'
2import type { ElementTable, EngineInterface, Register } from 'claude-code'
3
4import type { DecideItem } from '../types'
5
6const TOOL = 'mcp__decide__pending'
7const REMIND_MS = 20000
8const PANE = 'decide'
9const ROWS = 16
10
11const items = atom({ plugin: 'decide', key: 'items' } as const, [] as DecideItem[])
12
13// 固定文本：整个会话不变，不破坏 prompt cache
14const GUIDE = [
15  '需要用户拍板的事项（只有用户能定、不能按推荐直接做的），除了照常写在回复里，还要调用 mcp__decide__pending 的 add 登记：',
16  '每项一句问题，可选答案（推荐项放第一个），推荐哪个及理由，做决定需要的背景。',
17  '用户会在「等你拍板」面板里回答，答复以一条用户消息发回。可逆、你已经按推荐做了的事不登记。',
18  '用户在对话里直接答了某项，或某项已经不用定了，用同一工具的 resolve 传它的 id。不确定还有哪些待定时，不带参数调用它查看。',
19].join('')
20
21type Saved = { seq: number; items: DecideItem[] }
22let seq = 0
23// 上一次浮出提醒的时刻；同一插件的提醒会叠着显示，上一条还没消失就不再发
24let remindedAt = -Infinity
25
26const isAnswered = (item: DecideItem) => item.choice !== '' || item.note.trim() !== ''
27const storeKey = async ($: EngineInterface) => `session:${await $.session.id()}`
28
29async function change($: EngineInterface, fn: (list: DecideItem[]) => DecideItem[]): Promise<DecideItem[]> {
30  const next = fn(await read($, items))
31  await update($, items, () => next)
32  const key = await storeKey($)
33  if (next.length > 0) {
34    await $.store.set(key, { seq, items: next } satisfies Saved)
35  } else {
36    await $.store.delete(key)
37    await $.ui.close({ id: PANE })
38  }
39  return next
40}
41
42const paneOpen = async ($: EngineInterface) => (await $.ui.panes()).some(p => p.id === PANE)
43
44const strings = (value: unknown): string[] =>
45  Array.isArray(value) ? value.filter((v): v is string => typeof v === 'string' && v.trim() !== '') : []
46const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '')
47
48function summary(list: DecideItem[]): string {
49  if (list.length === 0) return '当前没有待定项。'
50  return `当前待定 ${list.length} 项：${list.map(i => `${i.id} ${i.question}`).join('；')}`
51}
52
53function answerText(list: DecideItem[]): string {
54  const lines = list.map((item, n) => {
55    const parts = [item.choice, item.note.trim()].filter(Boolean)
56    return `${n + 1}. ${item.id} ${item.question} → ${parts.join('；')}`
57  })
58  return ['我在待定面板里对下面几项的答复（这几项已从面板移除，不用再 resolve）：', ...lines].join('\n')
59}
60
61// 右上角浮出的提醒：最多显示三行，先写条数和怎么回答，问题放后面
62async function remind($: EngineInterface): Promise<void> {
63  const list = await read($, items)
64  const now = await $.clock.now()
65  if (list.length === 0 || now - remindedAt < REMIND_MS) return
66  remindedAt = now
67  const questions = list.map(i => `${i.id} ${i.question}`).join('；')
68  $.ui.toast(`${list.length} 项等你拍板 · /decide 回答：${questions}`, { timeoutMs: REMIND_MS })
69}
70
71type Ui = Pick<ElementTable<'terminal'>, 'Box' | 'Text' | 'Button' | 'Input'>
72
73function head({ Box, Text }: Ui, count: number, hint: string) {
74  return (
75    <Box flexDirection="row" gap={1}>
76      <Text color="warning" bold>
77        ▍待定
78      </Text>
79      <Text>{count} 项等你拍板</Text>
80      <Text dimColor>{hint}</Text>
81    </Box>
82  )
83}
84
85// 面板里的整个列表
86function sheet($: EngineInterface, ui: Ui, list: DecideItem[], hint: string) {
87  const { Box, Text, Button, Input } = ui
88  const answered = list.filter(isAnswered)
89  const edit = (id: string, patch: Partial<DecideItem>) =>
90    change($, current => current.map(i => (i.id === id ? { ...i, ...patch } : i)))
91  // 选项按顺序配数字 1–9，0 是提交
92  let digit = 0
93  const hotkey = () => (++digit <= 9 ? String(digit) : undefined)
94  return (
95    <Box flexDirection="column">
96      {head(ui, list.length, hint)}
97      {list.map((item, n) => (
98        <Box key={item.id} flexDirection="column" paddingLeft={2}>
99          <Text bold>
100            {item.id} {item.question}
101          </Text>
102          {item.context ? <Text dimColor>{item.context}</Text> : null}
103          {item.recommended ? <Text color="success">推荐：{item.recommended}</Text> : null}
104          {item.options.length > 0 ? (
105            <Box flexDirection="row" flexWrap="wrap" columnGap={2}>
106              {item.options.map((o, k) => (
107                <Button
108                  key={`choice-${item.id}-${k}`}
109                  label={`${item.choice === o ? '●' : '○'} ${o}`}
110                  hotkey={hotkey()}
111                  plain
112                  autoFocus={n === 0 && k === 0 ? true : undefined}
113                  onPress={() => void edit(item.id, { choice: item.choice === o ? '' : o })}
114                />
115              ))}
116            </Box>
117          ) : null}
118          <Box flexDirection="row" gap={2}>
119            <Input
120              key={`note-${item.id}`}
121              label={item.options.length > 0 ? '补充' : '答复'}
122              placeholder={item.options.length > 0 ? '可空' : '写你的答复'}
123              value={item.note}
124              submitLabel="记下"
125              autoFocus={n === 0 && item.options.length === 0 ? true : undefined}
126              onInput={value => void edit(item.id, { note: value })}
127              // Enter 会清空输入框，引擎只在画出的值变了时才把值填回去：先置空再写回
128              onSubmit={value => void edit(item.id, { note: '' }).then(() => edit(item.id, { note: value }))}
129            />
130            <Button key={`drop-${item.id}`} label="移除" plain dimColor onPress={() => void change($, c => c.filter(i => i.id !== item.id))} />
131          </Box>
132        </Box>
133      ))}
134      <Box paddingLeft={2}>
135        {answered.length > 0 ? (
136          <Button
137            key="submit"
138            label={`提交已答的 ${answered.length} 项`}
139            hotkey="0"
140            plain
141            onPress={async () => {
142              const done = (await read($, items)).filter(isAnswered)
143              if (done.length === 0) return
144              const ids = new Set(done.map(i => i.id))
145              await change($, current => current.filter(i => !ids.has(i.id)))
146              $.ui.toast(`已提交 ${done.length} 项，Claude 空闲后收到`)
147              // Claude 回答中途提交时，submit 要等这一轮结束才返回；等它会超过按钮处理的 10 秒时限
148              void $.prompt.submit({ text: answerText(done), asUser: true })
149            }}
150          />
151        ) : (
152          <Text dimColor>选一项或写了答复后才能提交</Text>
153        )}
154      </Box>
155    </Box>
156  )
157}
158
159export const register: Register = on => {
160  on('session.start', async ($, e, next) => {
161    // immediate：Claude 回答中途输入也立刻开关，不排到这一轮结束
162    await $.command.register({ name: 'decide', description: '打开 / 关闭「等你拍板」面板：选择、回答、提交待定事项', immediate: true })
163    await $.tool.register({
164      name: 'pending',
165      description: `登记、撤销和查看等用户拍板的事项。${GUIDE}返回当前全部待定项及其 id。`,
166      inputSchema: {
167        type: 'object',
168        properties: {
169          add: {
170            type: 'array',
171            description: '要登记的待定项',
172            items: {
173              type: 'object',
174              properties: {
175                question: { type: 'string', description: '一句话写清要用户定什么' },
176                options: { type: 'array', items: { type: 'string' }, description: '可选答案，推荐项放第一个；开放问题可省略' },
177                recommended: { type: 'string', description: '推荐哪个、为什么，一句话' },
178                context: { type: 'string', description: '做决定需要知道的背景，一两句' },
179              },
180              required: ['question'],
181            },
182          },
183          resolve: { type: 'array', items: { type: 'string' }, description: '不用再等的待定项 id' },
184        },
185      },
186    })
187    const saved = (await $.store.get(await storeKey($))) as Saved | undefined
188    seq = saved?.seq ?? 0
189    await update($, items, () => saved?.items ?? [])
190
191    return next(e)
192  })
193
194  on('prompt.compose', async ($, e, next) => {
195    const composed = await next(e)
196
197    return { ...composed, sections: [...composed.sections, { id: 'decide', text: GUIDE, scope: 'session' }] }
198  })
199
200  on('tool.check', { tool: TOOL }, () => ({ decision: 'allow' }))
201
202  on('tool.call', { tool: TOOL }, async ($, e) => {
203    const args = e as unknown as Record<string, unknown>
204    const added: DecideItem[] = (Array.isArray(args.add) ? args.add : [])
205      .map(raw => (typeof raw === 'object' && raw !== null ? (raw as Record<string, unknown>) : {}))
206      .filter(raw => text(raw.question) !== '')
207      .map(raw => ({
208        id: `D${++seq}`,
209        question: text(raw.question),
210        options: strings(raw.options),
211        recommended: text(raw.recommended),
212        context: text(raw.context),
213        choice: '',
214        note: '',
215      }))
216    const resolved = new Set(strings(args.resolve))
217    const list = await change($, current => [...current.filter(i => !resolved.has(i.id)), ...added])
218    if (added.length > 0) {
219      await remind($)
220    }
221    const head = added.length > 0 ? `已登记 ${added.map(i => i.id).join('、')}。` : ''
222
223    return { result: `${head}${summary(list)}` }
224  })
225
226  on('command.run', { command: 'decide' }, async $ => {
227    if ((await read($, items)).length === 0) {
228      $.ui.toast('没有等你拍板的事')
229    } else if (await paneOpen($)) {
230      await $.ui.close({ id: PANE })
231    } else {
232      // 面板拿着键盘：焦点落在第一个选项上，Esc 只关面板，不会中断 Claude
233      await $.ui.open({ id: PANE, title: '等你拍板', focus: true, closeOnEscape: true, rows: ROWS })
234      $.ui.invalidate('ui.render')
235    }
236
237    return {}
238  })
239
240  // 面板关掉后，输入框上方那一行重新画出来
241  on('ui.close', async ($, e, next) => {
242    const closed = await next(e)
243    if (e.id === PANE) $.ui.invalidate('ui.render')
244
245    return closed
246  })
247
248  // 每轮结束时还有没答的就再提醒一次
249  on('turn.complete', async ($, e, next) => {
250    await remind($)
251
252    return next(e)
253  })
254
255  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
256    const below = await next(e)
257    const list = await read($, items)
258    // 面板开着时列表在面板里，这一行先不画
259    if (list.length === 0 || e.props.hasSurvey || e.surface === 'mobile' || (await paneOpen($))) return below
260    const ui = $.ui.resolve(e)
261    const { Box } = ui
262
263    return (
264      <Box flexDirection="column">
265        {head(ui, list.length, '/decide 打开')}
266        {below}
267      </Box>
268    )
269  })
270
271  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
272    if (e.surface === 'mobile') {
273      const { Text } = $.ui.resolve(e)
274      return <Text>在对话里直接回答待定事项</Text>
275    }
276
277    return sheet($, $.ui.resolve(e), await read($, items), '数字键选 · ↑↓ 移动 · Esc 关闭')
278  })
279}
280

1export type DecideItem = {
2  id: string
3  question: string
4  options: string[]
5  recommended: string
6  context: string
7  choice: string
8  note: string
9}
10
11declare module 'claude-code' {
12  interface PluginState {
13    decide: { items: DecideItem[] }
14  }
15}
16