@leviyuan/lodestar 0.1.1 → 0.1.2

package/daemon.ts

@@ -140,6 +140,9 @@ async function handleCardAction(data: any): Promise<any> {
     case 'menu':
       await session.onUserMessage(`(menu choice ${value.choice + 1})`)
       return { toast: { type: 'success', content: 'OK' } }
+    case 'ask':
+      await session.onAskAnswer(value.tool_use_id, value.question_idx ?? 0, value.option_idx, userId)
+      return { toast: { type: 'success', content: '已回答' } }
   }
   return { toast: { type: 'info', content: 'unknown action' } }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leviyuan/lodestar",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "publishConfig": {
     "access": "public"
   },

package/src/cards.ts

@@ -19,6 +19,44 @@ export const ELEMENTS = {
   assistant: (i: number) => `assistant_${i}`,
 } as const
 
+/** Minimal projection of an SDK task — used by Session's local mirror,
+ * built incrementally from observed TaskCreate / TaskUpdate input+output
+ * pairs. Not authoritative (the SDK is the source of truth), but enough
+ * to render the "全部任务清单" footer on every Task* panel. */
+export interface Todo {
+  id: number
+  subject?: string
+  description?: string
+  status: 'pending' | 'in_progress' | 'completed' | string
+  owner?: string
+  activeForm?: string
+}
+
+function todoStatusIcon(s: string): string {
+  switch (s) {
+    case 'pending':     return '☐'
+    case 'in_progress': return '🔄'
+    case 'completed':   return '✅'
+    default:            return '·'
+  }
+}
+
+/** Render the session's full todo mirror as a markdown list. Empty list
+ * yields '' so callers can unconditionally concat. Sorted by numeric id
+ * so the order matches creation order regardless of Map iteration. */
+function renderTodoList(todos: Todo[]): string {
+  if (!todos || todos.length === 0) return ''
+  const sorted = [...todos].sort((a, b) => a.id - b.id)
+  const lines = ['', '---', `**📋 当前任务清单（${sorted.length} 项）**`, '']
+  for (const t of sorted) {
+    const icon = todoStatusIcon(t.status)
+    const subject = t.subject ?? '(无 subject)'
+    const ownerTag = t.owner ? `  · ${t.owner}` : ''
+    lines.push(`- ${icon} **#${t.id}** ${subject}${ownerTag}`)
+  }
+  return lines.join('\n')
+}
+
 /** Single-line summary used as a collapsible-panel header for a tool call. */
 export function summarizeToolInput(name: string, input: any): string {
   if (!input || typeof input !== 'object') return ''
@@ -81,8 +119,10 @@ function summarizeTaskWorkflow(name: string, input: any): string {
 /** Markdown body for Task* workflow tools — replaces the generic JSON
  * dump with a human-readable description of the operation plus, once the
  * tool result is in, the SDK's text reply (which already contains "Task
- * #N created" / "Updated task #X" / a rendered list for TaskList). */
-function renderTaskWorkflowBody(name: string, input: any, output: string | null): string {
+ * #N created" / "Updated task #X" / a rendered list for TaskList). When
+ * `todos` is non-empty, the full mirror is appended as a "📋 当前任务
+ * 清单" footer so every Task* panel doubles as a current-state readout. */
+function renderTaskWorkflowBody(name: string, input: any, output: string | null, todos?: Todo[]): string {
   const lines: string[] = []
   switch (name) {
     case 'TaskCreate':
@@ -118,7 +158,7 @@ function renderTaskWorkflowBody(name: string, input: any, output: string | null)
     lines.push('**结果**')
     lines.push(output.slice(0, 3000))
   }
-  return lines.join('\n')
+  return lines.join('\n') + renderTodoList(todos ?? [])
 }
 
 interface MainCardOpts {
@@ -191,6 +231,10 @@ export function toolCallElement(
   output: string | null,
   status: '⏳' | '✅' | '❌' = '⏳',
   resolvedNote?: string,
+  /** Session's full todo mirror — only rendered when the tool is a Task*
+   * workflow op. Other tools ignore it. Passed in by Session so every
+   * Task* panel shows the *current* state, not just this op's diff. */
+  todos?: Todo[],
 ): object {
   const summary = summarizeToolInput(name, input)
   const headerText = summary
@@ -198,11 +242,12 @@ export function toolCallElement(
     : `${status} 🔧 ${name}`
   const isTaskWorkflow = name.startsWith('Task') && name !== 'Task'
   const noteBlock = resolvedNote ? `\n\n${resolvedNote}` : ''
-  // Task* gets a narrative body (operation + result), the rest keeps the
-  // JSON-input + raw-output split — generic dump is better for unfamiliar
-  // tools where users can't predict what fields matter.
+  // Task* gets a narrative body (operation + result + current todo list),
+  // the rest keeps the JSON-input + raw-output split — generic dump is
+  // better for unfamiliar tools where users can't predict what fields
+  // matter.
   const body = isTaskWorkflow
-    ? renderTaskWorkflowBody(name, input, output) + noteBlock
+    ? renderTaskWorkflowBody(name, input, output, todos) + noteBlock
     : '```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 2000) + '\n```'
       + noteBlock
       + (output != null ? '\n---\n**output:**\n```\n' + output.slice(0, 3000) + '\n```' : '')
@@ -265,6 +310,92 @@ function permissionButtonColumn(label: string, type: string, requestId: string,
   }
 }
 
+/** Schema of an AskUserQuestion question, projected to just the fields
+ * the panel needs. Mirrors the SDK tool's input — kept loose since the
+ * runtime guarantees it matches. */
+export interface AskQuestion {
+  question: string
+  header?: string
+  multiSelect?: boolean
+  options: { label: string; description?: string }[]
+}
+
+/** Tool-panel renderer for `AskUserQuestion` — the SDK's structured
+ * multiple-choice question. Daemon takes over the client-side role:
+ * instead of letting the request fall through to the generic JSON
+ * dump (or worse, the permission flow that misappropriates it), we
+ * render each question with one button per option, callbacks tagged
+ * `kind:'ask'` so the Lark handler can route the answer back as a
+ * `tool_result`.
+ *
+ * Single-question is the common case; multi-question gets buttons on
+ * the first question only and a text-only listing for the rest (an
+ * acceptable limitation — these are rare in practice and we can lift
+ * it once the UX is validated). */
+export function askUserQuestionElement(
+  i: number,
+  toolUseId: string,
+  questions: AskQuestion[],
+  status: '🤔' | '✅' | '❌' = '🤔',
+  resolvedNote?: string,
+): object {
+  const primary = questions[0]
+  const headerTag = primary?.header ? ` · ${primary.header}` : ''
+  const headerText = `${status} 🤔 AskUserQuestion${headerTag}`
+  const bodyElements: any[] = []
+  if (primary) {
+    bodyElements.push({ tag: 'markdown', content: `**${primary.question}**` })
+    // Stack option buttons in a column_set — one button per option.
+    // Each carries `kind:'ask'` + the toolUseId + question/option idx
+    // so the daemon's card action handler can map a click back to
+    // exactly one (question, choice) pair.
+    bodyElements.push({
+      tag: 'column_set',
+      columns: primary.options.map((opt, optIdx) => ({
+        tag: 'column', width: 'weighted', weight: 1,
+        elements: [{
+          tag: 'button',
+          text: { tag: 'plain_text', content: opt.label },
+          type: 'default',
+          behaviors: [{
+            type: 'callback',
+            value: {
+              kind: 'ask',
+              tool_use_id: toolUseId,
+              question_idx: 0,
+              option_idx: optIdx,
+            },
+          }],
+        }],
+      })),
+    })
+    // Inline option descriptions below the buttons so the user can
+    // read context without hovering.
+    const descLines = primary.options
+      .map((o, idx) => o.description ? `- **${o.label}** — ${o.description}` : `- **${o.label}**`)
+      .join('\n')
+    if (descLines) bodyElements.push({ tag: 'markdown', content: descLines })
+  }
+  // Secondary questions get text-only treatment (TODO: multi-question
+  // panels when actually requested by a real prompt).
+  for (let qi = 1; qi < questions.length; qi++) {
+    const q = questions[qi]
+    const opts = q.options.map(o => `  - ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n')
+    bodyElements.push({
+      tag: 'markdown',
+      content: `\n---\n**(其他问题 #${qi + 1}, 暂未支持回答)** ${q.question}\n${opts}`,
+    })
+  }
+  if (resolvedNote) bodyElements.push({ tag: 'markdown', content: resolvedNote })
+  return {
+    tag: 'collapsible_panel',
+    element_id: ELEMENTS.tool(i),
+    header: { title: { tag: 'plain_text', content: headerText } },
+    expanded: true,
+    elements: bodyElements,
+  }
+}
+
 interface ConsoleOpts {
   sessionName: string
   status: 'idle' | 'working' | 'awaiting_permission' | 'starting' | 'stopped'

package/src/claude-process.ts

@@ -312,6 +312,31 @@ export class ClaudeProcess extends EventEmitter {
     })
   }
 
+  /** Feed a `tool_result` back to Claude as if a tool finished — used
+   * by the daemon when WE (the client) own the tool's execution side,
+   * e.g. AskUserQuestion: the SDK emits `tool_use` and waits for the
+   * client to render UI, collect a choice, and supply the result here.
+   * `content` is whatever the tool's contract says — for
+   * AskUserQuestion this is a JSON string `{"answers": {...}}`.
+   *
+   * NOTE: this is the same `{type:'user'}` envelope as `sendUserText`,
+   * just with a `tool_result` content block instead of plain text. The
+   * SDK demultiplexes by `tool_use_id`. */
+  sendToolResult(toolUseId: string, content: string, isError = false): void {
+    this.write({
+      type: 'user',
+      message: {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: toolUseId,
+          content,
+          ...(isError ? { is_error: true } : {}),
+        }],
+      },
+    })
+  }
+
   sendHookResponse(requestId: string, output: object = {}): void {
     this.write({
       type: 'control_response',

package/src/session.ts

@@ -22,7 +22,18 @@ interface TurnState {
   userText: string
   thinkingText: string
   toolCount: number
-  toolByUseId: Map<string, { i: number; name: string; input: any; resolvedNote?: string }>
+  /** `output` / `isError` are filled in by completeTool — kept on the
+   * meta (instead of being thrown away after the first render) so a
+   * later Task* op can re-render every prior Task* panel with the
+   * latest todo mirror appended. */
+  toolByUseId: Map<string, {
+    i: number
+    name: string
+    input: any
+    resolvedNote?: string
+    output?: string
+    isError?: boolean
+  }>
   assistantSegmentCount: number
   currentAssistantSegmentId: string | null
   currentAssistantText: string
@@ -65,6 +76,11 @@ export class Session {
   private proc: ClaudeProcess | null = null
   private currentTurn: TurnState | null = null
   private pendingPermissions = new Map<string, { toolUseId: string }>()
+  /** Open AskUserQuestion tool calls — keyed by tool_use_id, valued
+   * with the questions array so we can construct the `answers` reply
+   * once a button is clicked. Cleared when the answer is sent or the
+   * turn ends. */
+  private pendingAsks = new Map<string, { questions: cards.AskQuestion[]; i: number }>()
   private turnCounter = 0
   // Last seen sessionId — preserved across `kill`/`stop` so a later
   // `restart` can resume the same Claude conversation even after the
@@ -73,6 +89,13 @@ export class Session {
   private startedAt: number = 0
   private cumStats: CumStats = { tokens: 0, costUsd: 0, turns: 0 }
   private lastTurnDelta: LastTurnDelta | null = null
+  /** Local mirror of the SDK's task list — built incrementally from
+   * TaskCreate / TaskUpdate input+output pairs and rendered as a footer
+   * on every Task* panel. Lives for the lifetime of the Session
+   * instance; daemon restart wipes it (the SDK doesn't replay history).
+   * Not authoritative — Claude calling TaskList is still the source of
+   * truth; this mirror is purely for the panel readout. */
+  private currentTodos = new Map<number, cards.Todo>()
   status: Status = 'stopped'
 
   constructor(
@@ -270,13 +293,14 @@ export class Session {
     const turn = this.currentTurn
     const meta = turn?.toolByUseId.get(pending.toolUseId)
     if (turn && meta) {
+      const todos = this.isTaskWorkflow(meta.name) ? this.todosArray() : undefined
       if (decision === 'deny') {
-        const el = cards.toolCallElement(meta.i, meta.name, meta.input, `🚫 已拒绝 by ${user || '匿名'}`, '❌')
+        const el = cards.toolCallElement(meta.i, meta.name, meta.input, `🚫 已拒绝 by ${user || '匿名'}`, '❌', undefined, todos)
         void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
       } else {
         const label = decision === 'allow_always' ? '始终允许' : '已允许'
         meta.resolvedNote = `✅ **${label}** by ${user || '匿名'}`
-        const el = cards.toolCallElement(meta.i, meta.name, meta.input, null, '⏳', meta.resolvedNote)
+        const el = cards.toolCallElement(meta.i, meta.name, meta.input, null, '⏳', meta.resolvedNote, todos)
         void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
       }
     }
@@ -293,6 +317,42 @@ export class Session {
     }
   }
 
+  /** Handle a click on an AskUserQuestion option button. We construct
+   * the SDK-shaped `answers` map (question text → picked option label),
+   * send it back as a `tool_result`, and freeze the panel showing the
+   * picked option. The permission half of the flow was already auto-
+   * allowed in `renderPermission`, so no second action needed there. */
+  async onAskAnswer(toolUseId: string, questionIdx: number, optionIdx: number, user: string): Promise<void> {
+    const pending = this.pendingAsks.get(toolUseId)
+    if (!pending) { log(`session "${this.sessionName}": stray ask answer for ${toolUseId}`); return }
+    const q = pending.questions[questionIdx]
+    const opt = q?.options?.[optionIdx]
+    if (!q || !opt) {
+      log(`session "${this.sessionName}": ask answer out of range q=${questionIdx} o=${optionIdx}`)
+      return
+    }
+    // Build the answers map. SDK keys answers by the question text
+    // (matches what the AskUserQuestion contract expects). For
+    // unanswered secondary questions we don't include them — the SDK
+    // tolerates a partial map; Claude will see whichever it got.
+    const answers: Record<string, string> = { [q.question]: opt.label }
+    const content = JSON.stringify({ answers })
+    this.proc?.sendToolResult(toolUseId, content)
+    this.pendingAsks.delete(toolUseId)
+
+    // Repaint the panel to reflect the final choice — same element_id,
+    // status flips to ✅, body shows what was picked.
+    const turn = this.currentTurn
+    const meta = turn?.toolByUseId.get(toolUseId)
+    if (turn && meta) {
+      meta.output = content
+      meta.isError = false
+      const resolvedNote = `\n\n✅ **已回答** by ${user || '匿名'}: ${opt.label}`
+      const el = cards.askUserQuestionElement(meta.i, toolUseId, pending.questions, '✅', resolvedNote)
+      void cardkit.replaceElement(turn.cardId, cards.ELEMENTS.tool(meta.i), el)
+    }
+  }
+
   async onConsoleAction(action: string): Promise<void> {
     log(`session "${this.sessionName}": console action=${action}`)
     switch (action) {
@@ -446,6 +506,14 @@ export class Session {
     )
   }
 
+  private isTaskWorkflow(name: string): boolean {
+    return name.startsWith('Task') && name !== 'Task'
+  }
+
+  private todosArray(): cards.Todo[] {
+    return [...this.currentTodos.values()]
+  }
+
   private addTool(toolUseId: string, name: string, input: any): void {
     if (!this.currentTurn) return
     // Close current assistant segment (if any) so the tool panel renders
@@ -458,7 +526,27 @@ export class Session {
     }
     const i = this.currentTurn.toolCount++
     this.currentTurn.toolByUseId.set(toolUseId, { i, name, input })
-    const el = cards.toolCallElement(i, name, input, null, '⏳')
+    // AskUserQuestion is a client-side tool — daemon renders the choice
+    // UI in-line and supplies the tool_result itself once the user
+    // clicks. Branch BEFORE the generic toolCallElement so we never
+    // fall through to a JSON dump or, worse, get clobbered by the
+    // permission flow (which would render 🔐 three-button buttons that
+    // don't match the actual N options).
+    if (name === 'AskUserQuestion') {
+      const questions = Array.isArray(input?.questions) ? input.questions as cards.AskQuestion[] : []
+      this.pendingAsks.set(toolUseId, { questions, i })
+      const el = cards.askUserQuestionElement(i, toolUseId, questions, '🤔')
+      void cardkit.addElement(this.currentTurn.cardId, el, {
+        type: 'insert_before',
+        targetElementId: cards.ELEMENTS.footer,
+      })
+      return
+    }
+    // Pending Task* panels still show the *pre-op* todo mirror so users
+    // can read the current state immediately, without waiting for the
+    // tool to return.
+    const todos = this.isTaskWorkflow(name) ? this.todosArray() : undefined
+    const el = cards.toolCallElement(i, name, input, null, '⏳', undefined, todos)
     void cardkit.addElement(this.currentTurn.cardId, el, {
       type: 'insert_before',
       targetElementId: cards.ELEMENTS.footer,
@@ -474,8 +562,89 @@ export class Session {
       : Array.isArray(content)
         ? content.map((c: any) => c?.text ?? JSON.stringify(c)).join('\n')
         : JSON.stringify(content)
-    const el = cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅', meta.resolvedNote)
+    // Stash on the meta — every Task* op coming after this point may
+    // need to re-render this panel with a fresher todo footer, so we
+    // can't discard the output after the first paint.
+    meta.output = output
+    meta.isError = isError
+    // Update the local todo mirror BEFORE rendering so the just-
+    // completed panel shows the new state too (e.g. a TaskCreate panel
+    // already lists the task it just created).
+    if (!isError && this.isTaskWorkflow(meta.name)) {
+      this.updateTodosFromTask(meta.name, meta.input, output)
+    }
+    const todos = this.isTaskWorkflow(meta.name) ? this.todosArray() : undefined
+    const el = cards.toolCallElement(meta.i, meta.name, meta.input, output, isError ? '❌' : '✅', meta.resolvedNote, todos)
     void cardkit.replaceElement(this.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
+    // Cascade the new mirror into every prior Task* panel in this turn
+    // so any expanded panel reflects the latest state, not the snapshot
+    // captured when that op ran.
+    if (!isError && this.isTaskWorkflow(meta.name)) {
+      this.refreshOtherTaskPanels(toolUseId)
+    }
+  }
+
+  /** Roll a single Task* op into the local mirror — best-effort. Output
+   * parsing is regex-based (the SDK returns plain text like "Task #7
+   * created successfully: …"), so unexpected variants are skipped
+   * silently rather than blowing up the panel render. */
+  private updateTodosFromTask(name: string, input: any, output: string): void {
+    switch (name) {
+      case 'TaskCreate': {
+        const m = output.match(/Task #(\d+) created/)
+        if (!m) return
+        const id = Number(m[1])
+        this.currentTodos.set(id, {
+          id,
+          subject: input.subject,
+          description: input.description,
+          activeForm: input.activeForm,
+          status: 'pending',
+        })
+        return
+      }
+      case 'TaskUpdate': {
+        const id = Number(input.taskId)
+        if (!Number.isFinite(id)) return
+        // status=deleted is the SDK's tombstone — drop from the mirror
+        // so the readout doesn't carry it forever. Server still keeps
+        // it; the mirror is just for the panel footer.
+        if (input.status === 'deleted') { this.currentTodos.delete(id); return }
+        const cur = this.currentTodos.get(id) ?? { id, status: 'pending' as const }
+        if (input.status)      cur.status = input.status
+        if (input.subject)     cur.subject = input.subject
+        if (input.description) cur.description = input.description
+        if (input.owner)       cur.owner = input.owner
+        if (input.activeForm)  cur.activeForm = input.activeForm
+        this.currentTodos.set(id, cur)
+        return
+      }
+      // TaskList / TaskGet / TaskStop / TaskOutput / TaskDelete:
+      // read-only or parse-heavy — skip mirror update. The panel will
+      // still render the SDK's textual result below the operation
+      // block, which is enough to disambiguate.
+    }
+  }
+
+  /** Re-render every Task* panel in the current turn (except the one
+   * that just landed — already up-to-date) so they all show the latest
+   * todo mirror in their footers. Cheap: ELEMENTS.tool(i) replace is
+   * queued through the per-card Promise chain like any other op. */
+  private refreshOtherTaskPanels(skipToolUseId: string): void {
+    if (!this.currentTurn) return
+    const todos = this.todosArray()
+    for (const [id, meta] of this.currentTurn.toolByUseId) {
+      if (id === skipToolUseId) continue
+      if (!this.isTaskWorkflow(meta.name)) continue
+      const status: '⏳' | '✅' | '❌' = meta.output === undefined
+        ? '⏳'
+        : (meta.isError ? '❌' : '✅')
+      const el = cards.toolCallElement(
+        meta.i, meta.name, meta.input, meta.output ?? null,
+        status, meta.resolvedNote, todos,
+      )
+      void cardkit.replaceElement(this.currentTurn.cardId, cards.ELEMENTS.tool(meta.i), el)
+    }
   }
 
   /** Merge the permission ask into the existing tool element in the
@@ -511,6 +680,19 @@ export class Session {
       this.proc?.sendPermissionResponse(req.request_id, 'deny', { denyMessage: 'unknown tool_use_id' })
       return
     }
+    // AskUserQuestion: daemon already rendered the choice UI in addTool
+    // and is collecting the user's answer asynchronously. The SDK
+    // wraps it in the standard permission flow anyway (even under
+    // bypassPermissions), so we auto-allow the request — otherwise
+    // Claude would block on can_use_tool forever, AND our permission
+    // renderer would overwrite the ask UI with the wrong 3-button
+    // panel. Keeping it allow-by-default also matches the user's
+    // mental model: they expect to choose an option, not "approve"
+    // the question itself.
+    if (meta.name === 'AskUserQuestion') {
+      this.proc?.sendPermissionResponse(req.request_id, 'allow')
+      return
+    }
     this.status = 'awaiting_permission'
     this.pendingPermissions.set(req.request_id, { toolUseId })
     const el = cards.toolCallPermissionElement(meta.i, meta.name, meta.input, req.request_id)