@leviyuan/lodestar 0.2.9 → 0.3.0

package/src/cards/elements.ts

@@ -1,22 +0,0 @@
-/**
- * Element-id convention (must be unique within a card):
- *   user_input        — the collapsible "你说" panel
- *   thinking          — the de-emphasized thinking stream
- *   tool_<i>          — one collapsible per tool call, indexed from 0
- *   assistant         — the main streaming assistant answer
- *   footer            — runtime footer (timing / status)
- */
-export const ELEMENTS = {
-  thinking: 'thinking',
-  footer: 'footer',
-  tool: (i: number) => `tool_${i}`,
-  /** Assistant text is segmented: every tool call closes the running segment
-   * and the next assistant chunk opens a new one, so element order in the
-   * card matches Claude's emission order. */
-  assistant: (i: number) => `assistant_${i}`,
-  /** Console (hi) card — the subscription-usage row is rendered as its
-   * own element so we can replace it after the initial card lands,
-   * decoupling the slow ccusage fetch from the rest of the panel's
-   * synchronous data. */
-  consoleUsage: 'console_usage',
-} as const

package/src/cards/turn.ts

@@ -1,530 +0,0 @@
-/**
- * Schema 2.0 turn-card templates: the main streaming card, the per-tool
- * collapsible panels, and the AskUserQuestion interactive panel. All
- * rendering for "the in-flight conversation card" lives here. Console
- * UI lives in console.ts; the shared element-id convention is in
- * elements.ts.
- */
-
-import { ELEMENTS } from './elements'
-
-/** 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 ''
-  const truncate = (s: string, n: number) => s.length > n ? s.slice(0, n) + '…' : s
-  // Task workflow tools (TaskCreate / TaskUpdate / TaskList / ...) carry
-  // structured fields that summarize much better as natural language than
-  // as truncated JSON. Routed first so they don't fall through to the
-  // generic Agent/Task case below.
-  if (name.startsWith('Task') && name !== 'Task') {
-    return truncate(summarizeTaskWorkflow(name, input), 80)
-  }
-  switch (name) {
-    case 'Bash':       return truncate(String(input.description ?? input.command ?? ''), 80)
-    case 'Read':
-    case 'Write':
-    case 'Edit':
-    case 'NotebookEdit': return truncate(String(input.file_path ?? ''), 80)
-    case 'Glob':       return truncate(String(input.pattern ?? ''), 80)
-    case 'Grep':       return truncate(`${input.pattern ?? ''}${input.path ? ' in ' + input.path : ''}`, 80)
-    case 'WebFetch':
-    case 'WebSearch': return truncate(String(input.url ?? input.query ?? ''), 80)
-    case 'Agent':
-    case 'Task':       return truncate(String(input.description ?? input.subject ?? ''), 80)
-    case 'Skill':      return truncate(String(input.skill ?? ''), 80)
-  }
-  // generic fallback: first string-valued field
-  for (const v of Object.values(input)) {
-    if (typeof v === 'string' && v) return truncate(v, 80)
-  }
-  return ''
-}
-
-/** Header summary for Task* workflow tools — `Task` (singular) is the
- * separate subagent-spawn tool and is handled above; everything else
- * (TaskCreate / TaskUpdate / TaskList / TaskGet / TaskStop / TaskOutput /
- * TaskDelete) summarises through here. */
-function summarizeTaskWorkflow(name: string, input: any): string {
-  switch (name) {
-    case 'TaskCreate':
-      return `📝 创建: ${input.subject ?? '(无 subject)'}`
-    case 'TaskUpdate': {
-      const parts: string[] = []
-      if (input.status) parts.push(`→ ${input.status}`)
-      if (input.owner) parts.push(`owner=${input.owner}`)
-      if (input.subject) parts.push(`subject="${input.subject}"`)
-      if (input.addBlocks) parts.push(`blocks=[${(input.addBlocks ?? []).join(',')}]`)
-      if (input.addBlockedBy) parts.push(`blockedBy=[${(input.addBlockedBy ?? []).join(',')}]`)
-      const tail = parts.length ? ' ' + parts.join(', ') : ''
-      return `✏️ #${input.taskId ?? '?'}${tail}`
-    }
-    case 'TaskList':   return '📋 查询任务列表'
-    case 'TaskGet':    return `🔍 查询 #${input.taskId ?? '?'}`
-    case 'TaskStop':   return `⏹ 停止 #${input.taskId ?? '?'}`
-    case 'TaskOutput': return `📤 取输出 #${input.taskId ?? '?'}`
-    case 'TaskDelete': return `🗑 删除 #${input.taskId ?? '?'}`
-  }
-  return name
-}
-
-/** 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). 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':
-      lines.push(`**📝 创建任务**`)
-      if (input.subject)    lines.push(`- subject: ${input.subject}`)
-      if (input.description) lines.push(`- 描述: ${input.description}`)
-      if (input.activeForm) lines.push(`- 进行时: ${input.activeForm}`)
-      break
-    case 'TaskUpdate': {
-      lines.push(`**✏️ 更新 #${input.taskId ?? '?'}**`)
-      if (input.status)       lines.push(`- status → \`${input.status}\``)
-      if (input.subject)      lines.push(`- subject: ${input.subject}`)
-      if (input.description)  lines.push(`- description: ${input.description}`)
-      if (input.owner)        lines.push(`- owner: ${input.owner}`)
-      if (input.activeForm)   lines.push(`- 进行时: ${input.activeForm}`)
-      if (input.addBlocks)    lines.push(`- blocks → ${(input.addBlocks).join(', ')}`)
-      if (input.addBlockedBy) lines.push(`- blockedBy → ${(input.addBlockedBy).join(', ')}`)
-      if (input.metadata)     lines.push(`- metadata: \`${JSON.stringify(input.metadata)}\``)
-      break
-    }
-    case 'TaskList':   lines.push('**📋 查询当前任务清单**'); break
-    case 'TaskGet':    lines.push(`**🔍 查询 #${input.taskId ?? '?'}**`); break
-    case 'TaskStop':   lines.push(`**⏹ 停止 #${input.taskId ?? '?'}**`); break
-    case 'TaskOutput': lines.push(`**📤 取 #${input.taskId ?? '?'} 输出**`); break
-    case 'TaskDelete': lines.push(`**🗑 删除 #${input.taskId ?? '?'}**`); break
-    default:
-      lines.push(`**${name}**`)
-      lines.push('```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 1000) + '\n```')
-  }
-  if (output != null) {
-    lines.push('')
-    lines.push('---')
-    lines.push('**结果**')
-    lines.push(output.slice(0, 3000))
-  }
-  return lines.join('\n') + renderTodoList(todos ?? [])
-}
-
-interface MainCardOpts {
-  sessionName: string
-  turn: number
-  model?: string
-  effort?: string
-  /** What started this turn. `'scheduled'` adds a top-of-card banner so
-   * the user can tell a cron-fired wakeup apart from one of their own
-   * messages — the user's message bubble is otherwise the only visual
-   * cue, and scheduled turns have no preceding bubble in the chat. */
-  kind?: 'user_message' | 'scheduled'
-}
-
-/** Initial card sent at the start of each turn. Streaming on. */
-export function mainConversationCard(opts: MainCardOpts): object {
-  const banner = opts.kind === 'scheduled'
-    ? [{ tag: 'markdown', content: '⏰ 触发' }]
-    : []
-  return {
-    schema: '2.0',
-    config: {
-      streaming_mode: true,
-      summary: { content: '[Lodestar 正在生成…]' },
-      streaming_config: {
-        print_frequency_ms: { default: 60, android: 60, ios: 60, pc: 30 },
-        print_step: { default: 2, android: 2, ios: 2, pc: 4 },
-        print_strategy: 'fast',
-      },
-    },
-    body: {
-      // Initial body has just thinking + footer; assistant segments and tool
-      // panels are inserted between them in real time as Claude streams.
-      // Note: empty-string content is rejected by CardKit PUT so the
-      // thinking element starts with a single space placeholder; the first
-      // real append overwrites it. No echo of the user's message inside
-      // the card — the chat bubble above already shows it.
-      elements: [
-        ...banner,
-        { tag: 'markdown', element_id: ELEMENTS.thinking, content: ' ' },
-        { tag: 'markdown', element_id: ELEMENTS.footer, content: '⏳ working…' },
-      ],
-    },
-  }
-}
-
-/** Empty assistant segment to be inserted just before the footer. */
-export function assistantSegmentElement(i: number): object {
-  return { tag: 'markdown', element_id: ELEMENTS.assistant(i), content: ' ' }
-}
-
-/** Final state for the thinking section once a turn closes — collapse the
- * full thinking text into a panel so the card stays clean.  Replaces the
- * top-level `thinking` markdown element via PUT /elements/:id. */
-export function thinkingCollapsedPanel(fullText: string): object {
-  const trimmed = fullText.trim()
-  return {
-    tag: 'collapsible_panel',
-    element_id: ELEMENTS.thinking,
-    header: { title: { tag: 'plain_text', content: `💭 思考过程 (${trimmed.length} 字)` } },
-    expanded: false,
-    elements: [
-      { tag: 'markdown', content: trimmed.slice(0, 8000) || '_(空)_' },
-    ],
-  }
-}
-
-/** Element to insert for each tool call. Expandable for big results.
- *
- * Header is a one-line summary: status + name + summarized input.
- * Body holds the full input + (after completion) the full output.
- * `resolvedNote` is an optional one-liner appended below the input —
- * used to surface "✅ 允许 by Alice" inline after a permission decision
- * lands but before the actual tool execution completes. */
-export function toolCallElement(
-  i: number,
-  name: string,
-  input: any,
-  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
-    ? `${status} 🔧 ${name}: ${summary}`
-    : `${status} 🔧 ${name}`
-  const isTaskWorkflow = name.startsWith('Task') && name !== 'Task'
-  const noteBlock = resolvedNote ? `\n\n${resolvedNote}` : ''
-  // 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, 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```' : '')
-  return {
-    tag: 'collapsible_panel',
-    element_id: ELEMENTS.tool(i),
-    header: { title: { tag: 'plain_text', content: headerText } },
-    expanded: false,
-    elements: [
-      { tag: 'markdown', content: body },
-    ],
-  }
-}
-
-/** Merged panel for a run of consecutive `Read` tool calls in one turn.
- * Header shows the dynamic count (`Read · 3 次`), body lists one row per
- * Read with its own status + file path. Replaces the individual panels
- * once a second Read joins the batch — single Reads still render as the
- * full `toolCallElement` (with file-contents dump on completion). */
-export function readBatchElement(
-  i: number,
-  items: Array<{ input: any; output: string | null; isError: boolean }>,
-): object {
-  const n = items.length
-  const anyError = items.some(it => it.isError)
-  const allDone = items.every(it => it.output !== null)
-  const status = anyError ? '❌' : allDone ? '✅' : '⏳'
-  const headerText = `${status} 🔧 Read · ${n} 次`
-  const lines = items.map(it => `\`${String(it.input.file_path ?? '(无 path)')}\``)
-  return {
-    tag: 'collapsible_panel',
-    element_id: ELEMENTS.tool(i),
-    header: { title: { tag: 'plain_text', content: headerText } },
-    expanded: false,
-    elements: [{ tag: 'markdown', content: lines.join('\n') }],
-  }
-}
-
-/** Same tool panel as `toolCallElement`, but with the 🔐 status and
- * three inline action buttons (allow / allow_always / deny). Expanded
- * by default so the user can read the request without clicking through.
- * This is the "merge into tool panel" UX — the permission decision
- * lives on the same row as the tool call instead of as a separate
- * floating card. */
-export function toolCallPermissionElement(
-  i: number,
-  name: string,
-  input: any,
-  requestId: string,
-): object {
-  const summary = summarizeToolInput(name, input)
-  const headerText = summary
-    ? `🔐 等审批 · ${name}: ${summary}`
-    : `🔐 等审批 · ${name}`
-  const inputBlock = '```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 2000) + '\n```'
-  return {
-    tag: 'collapsible_panel',
-    element_id: ELEMENTS.tool(i),
-    header: { title: { tag: 'plain_text', content: headerText } },
-    expanded: true,
-    elements: [
-      { tag: 'markdown', content: inputBlock },
-      {
-        tag: 'column_set',
-        columns: [
-          permissionButtonColumn('✅ 允许', 'primary', requestId, 'allow'),
-          permissionButtonColumn('♾️ 始终允许', 'default', requestId, 'allow_always'),
-          permissionButtonColumn('❌ 拒绝', 'danger', requestId, 'deny'),
-        ],
-      },
-    ],
-  }
-}
-
-function permissionButtonColumn(label: string, type: string, requestId: string, decision: string): object {
-  return {
-    tag: 'column', width: 'weighted', weight: 1,
-    elements: [{
-      tag: 'button',
-      text: { tag: 'plain_text', content: label },
-      type,
-      behaviors: [{ type: 'callback', value: { kind: 'permission', request_id: requestId, decision } }],
-    }],
-  }
-}
-
-/** 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 }[]
-}
-
-/** Per-question final-state. Mutually-exclusive branches: option pick
- * vs. free-form custom text. */
-export interface AskAnswered {
-  optionIdx?: number
-  customText?: string
-  user?: string
-}
-
-/** State the panel renders against. `currentIdx` undefined → terminal
- * (every question answered). Otherwise it's the question currently on
- * screen; everything in `answered` is history. */
-export interface AskState {
-  currentIdx?: number
-  answered: Map<number, AskAnswered>
-}
-
-/** Render one question's body — either as clickable interactive_container
- * rows (when picked === undefined) or as plain markdown summary
- * (already-answered, shown in history-panel context). */
-function renderAskQuestionBody(
-  q: AskQuestion,
-  toolUseId: string,
-  questionIdx: number,
-  picked?: AskAnswered,
-): any[] {
-  const els: any[] = []
-  els.push({ tag: 'markdown', content: `**${q.question}**` })
-  for (let oi = 0; oi < q.options.length; oi++) {
-    const opt = q.options[oi]
-    const desc = opt.description ? `  ·  ${opt.description}` : ''
-    if (picked) {
-      const isPicked = picked.optionIdx === oi
-      els.push({
-        tag: 'markdown',
-        content: isPicked
-          ? `✅ **${opt.label}**${desc}`
-          : `~~◯ ${opt.label}${desc}~~`,
-      })
-    } else {
-      els.push({
-        tag: 'interactive_container',
-        background_style: 'default',
-        has_border: true,
-        corner_radius: '6px',
-        padding: '8px 12px',
-        margin: '4px 0px 4px 0px',
-        behaviors: [{
-          type: 'callback',
-          value: {
-            kind: 'ask',
-            tool_use_id: toolUseId,
-            question_idx: questionIdx,
-            option_idx: oi,
-          },
-        }],
-        elements: [{ tag: 'markdown', content: `**${opt.label}**${desc}` }],
-      })
-    }
-  }
-  if (picked?.customText) {
-    els.push({ tag: 'markdown', content: `✏️ **自定义回答**：${picked.customText}` })
-  }
-  return els
-}
-
-/** Folded "📜 已答 N 题" panel — option C from the multi-question
- * design discussion. Returns null when there's no history to show. */
-function renderAskHistoryPanel(
-  questions: AskQuestion[],
-  answered: Map<number, AskAnswered>,
-): any | null {
-  if (answered.size === 0) return null
-  const lines: string[] = []
-  const sortedIdx = [...answered.keys()].sort((a, b) => a - b)
-  for (const idx of sortedIdx) {
-    const q = questions[idx]
-    const a = answered.get(idx)!
-    const tag = q?.header ?? `Q${idx + 1}`
-    const value = a.customText
-      ?? (a.optionIdx !== undefined ? q?.options[a.optionIdx]?.label : undefined)
-      ?? '?'
-    lines.push(`- ✅ **${tag}**：${value}`)
-  }
-  return {
-    tag: 'collapsible_panel',
-    header: {
-      title: { tag: 'plain_text', content: `📜 已答 ${answered.size} 题（点击展开）` },
-    },
-    expanded: false,
-    elements: [{ tag: 'markdown', content: lines.join('\n') }],
-  }
-}
-
-/** 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: '🤔' | '✅' | '❌' = '🤔',
-  state?: AskState,
-): object {
-  const total = questions.length
-  const answered = state?.answered ?? new Map<number, AskAnswered>()
-  const currentIdx = state?.currentIdx
-  const isTerminal = currentIdx === undefined && answered.size > 0
-  const bodyElements: any[] = []
-  let headerText: string
-
-  if (isTerminal) {
-    // All questions resolved — collapse and roll up answers in header
-    // + body. Single-question case keeps the old "已回答：xxx" header
-    // style; multi-question gets a "已回答 · N 题" count and a flat
-    // listing of Q→A pairs in the body.
-    if (total === 1) {
-      const q0 = questions[0]
-      const a0 = answered.get(0)
-      const value = a0?.customText
-        ?? (a0?.optionIdx !== undefined ? q0?.options[a0.optionIdx]?.label : undefined)
-        ?? '?'
-      const headerTag = q0?.header ? ` · ${q0.header}` : ''
-      headerText = `${status} 已回答${headerTag}：${value}`
-    } else {
-      headerText = `${status} 已回答 · ${total} 题`
-    }
-    const sortedIdx = [...answered.keys()].sort((a, b) => a - b)
-    for (const idx of sortedIdx) {
-      const q = questions[idx]
-      const a = answered.get(idx)!
-      const tag = q?.header ?? `Q${idx + 1}`
-      const value = a.customText
-        ?? (a.optionIdx !== undefined ? q?.options[a.optionIdx]?.label : undefined)
-        ?? '?'
-      bodyElements.push({
-        tag: 'markdown',
-        content: `**${tag}**：${value}`,
-      })
-    }
-    const lastUser = [...answered.values()].reverse().find(a => a.user)?.user
-    if (lastUser) {
-      bodyElements.push({
-        tag: 'markdown',
-        content: `\n*— 由 ${lastUser} 回答*`,
-      })
-    }
-  } else if (currentIdx !== undefined && questions[currentIdx]) {
-    // In-progress: render current question + folded history above.
-    // Progress tag in header lets the user see how many are left,
-    // even with the history panel folded.
-    const q = questions[currentIdx]
-    const headerTag = q.header ? ` · ${q.header}` : ''
-    const progress = total > 1 ? ` (${currentIdx + 1}/${total})` : ''
-    headerText = `${status} 🤔 AskUserQuestion${headerTag}${progress}`
-    const history = renderAskHistoryPanel(questions, answered)
-    if (history) bodyElements.push(history)
-    bodyElements.push(...renderAskQuestionBody(q, toolUseId, currentIdx))
-    bodyElements.push({
-      tag: 'markdown',
-      content: '_💬 也可以直接在群里回复你的答案（裸词命令 `hi`/`kill`/`restart`/`clear` 仍然优先）_',
-    })
-  } else {
-    // Defensive fallback — neither answered nor a valid currentIdx.
-    headerText = `${status} 🤔 AskUserQuestion`
-    if (questions[0]) {
-      bodyElements.push({ tag: 'markdown', content: `**${questions[0].question}**` })
-    }
-  }
-
-  return {
-    tag: 'collapsible_panel',
-    element_id: ELEMENTS.tool(i),
-    header: { title: { tag: 'plain_text', content: headerText } },
-    expanded: !isTerminal,
-    elements: bodyElements,
-  }
-}

package/src/cards.ts

@@ -1,32 +0,0 @@
-/**
- * Schema 2.0 Feishu card templates — barrel re-export. Each call site
- * uses `import * as cards from './cards'` and reaches everything through
- * this file. Internal split so each module stays under Claude Code's
- * per-read token budget:
- *   - cards/elements.ts — ELEMENTS (shared element-id helpers)
- *   - cards/turn.ts     — main turn card, tool panels, ask panels, todos
- *   - cards/console.ts  — console + menu cards, formatters,
- *                          streamingOffSettings
- */
-
-export { ELEMENTS } from './cards/elements'
-export {
-  type Todo,
-  type AskQuestion,
-  type AskAnswered,
-  type AskState,
-  summarizeToolInput,
-  mainConversationCard,
-  assistantSegmentElement,
-  thinkingCollapsedPanel,
-  toolCallElement,
-  readBatchElement,
-  toolCallPermissionElement,
-  askUserQuestionElement,
-} from './cards/turn'
-export {
-  consoleUsageContent,
-  consoleCard,
-  menuCard,
-  streamingOffSettings,
-} from './cards/console'