@leviyuan/lodestar 0.1.0 → 2.0.14

package/src/cardkit.ts

@@ -1,215 +0,0 @@
-/**
- * Feishu Card Kit v1 wrapper.
- *
- * Endpoints used (base = https://open.feishu.cn/open-apis/cardkit/v1):
- *   POST   /cards/id_convert                              message_id → card_id
- *   POST   /cards                                         create a card entity
- *   PUT    /cards/:card_id/elements/:element_id/content   stream text (typewriter)
- *   POST   /cards/:card_id/elements                       add element
- *   PUT    /cards/:card_id/elements/:element_id           replace element
- *   DELETE /cards/:card_id/elements/:element_id           remove element
- *   PATCH  /cards/:card_id/settings                       toggle streaming_mode etc.
- *
- * Per-card invariants enforced here:
- *   - `sequence` is monotonically increasing per card_id
- *   - all writes for a card are serialized through a Promise queue
- *   - text-streaming PUTs are batched on a 120ms / 32-char heuristic to
- *     stay well under cardkit's per-card rate ceiling
- */
-
-import { getTenantToken } from './feishu'
-import { log } from './log'
-
-const BASE = 'https://open.feishu.cn/open-apis/cardkit/v1'
-
-const FLUSH_INTERVAL_MS = 120
-const FLUSH_MIN_DELTA = 32
-
-interface CardState {
-  sequence: number
-  queue: Promise<void>
-  buffer: Map<string, string>          // element_id → latest full text
-  lastSent: Map<string, string>        // element_id → text last actually PUT
-  flushTimer: ReturnType<typeof setTimeout> | null
-}
-
-const cards = new Map<string, CardState>()
-
-function state(cardId: string): CardState {
-  let s = cards.get(cardId)
-  if (!s) {
-    s = {
-      sequence: 0,
-      queue: Promise.resolve(),
-      buffer: new Map(),
-      lastSent: new Map(),
-      flushTimer: null,
-    }
-    cards.set(cardId, s)
-  }
-  return s
-}
-
-function nextSeq(cardId: string): number {
-  const s = state(cardId)
-  s.sequence += 1
-  return s.sequence
-}
-
-async function call(method: string, path: string, body?: object): Promise<any> {
-  const token = await getTenantToken()
-  const res = await fetch(`${BASE}${path}`, {
-    method,
-    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-    ...(body ? { body: JSON.stringify(body) } : {}),
-  })
-  const json = await res.json() as any
-  if (json?.code && json.code !== 0) {
-    throw new Error(`cardkit ${method} ${path}: code=${json.code} msg=${json.msg}`)
-  }
-  return json?.data
-}
-
-/** Convert a sent interactive message into a card entity. */
-export async function convertMessageToCard(messageId: string): Promise<string> {
-  const data = await call('POST', '/cards/id_convert', { message_id: messageId })
-  return data.card_id
-}
-
-/** Create a card entity from raw schema-2.0 card JSON. */
-export async function createCardEntity(card: object): Promise<string> {
-  const data = await call('POST', '/cards', {
-    type: 'card_json',
-    data: JSON.stringify(card),
-  })
-  return data.card_id
-}
-
-/** PUT element content (full text) — triggers typewriter on prefix-match.
- *
- * NOTE: CardKit rejects empty-string content with code 99992402 ("field
- * validation failed"); we drop empty/whitespace-only writes here so callers
- * can stream naively without per-call empty checks. */
-export function streamText(cardId: string, elementId: string, content: string): Promise<void> {
-  if (!content || !content.trim()) return Promise.resolve()
-  const s = state(cardId)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
-      await call('PUT', `/cards/${cardId}/elements/${elementId}/content`, {
-        content, sequence: seq,
-      })
-      s.lastSent.set(elementId, content)
-    } catch (e) {
-      log(`cardkit streamText ${cardId}/${elementId}: ${e}`)
-    }
-  })
-  return s.queue
-}
-
-/** Throttled streaming: buffer + auto-flush every FLUSH_INTERVAL_MS or
- * when the buffered delta crosses FLUSH_MIN_DELTA characters. */
-export function streamTextThrottled(cardId: string, elementId: string, fullContent: string): void {
-  if (!fullContent || !fullContent.trim()) return
-  const s = state(cardId)
-  s.buffer.set(elementId, fullContent)
-
-  const last = s.lastSent.get(elementId) ?? ''
-  const delta = fullContent.length - last.length
-  if (delta >= FLUSH_MIN_DELTA) {
-    flush(cardId).catch(e => log(`cardkit flush(min-delta) ${cardId}: ${e}`))
-    return
-  }
-  if (!s.flushTimer) {
-    s.flushTimer = setTimeout(() => {
-      flush(cardId).catch(e => log(`cardkit flush(timer) ${cardId}: ${e}`))
-    }, FLUSH_INTERVAL_MS)
-  }
-}
-
-/** Force an immediate flush of the buffered streams for a card. */
-export async function flush(cardId: string): Promise<void> {
-  const s = cards.get(cardId)
-  if (!s) return
-  if (s.flushTimer) { clearTimeout(s.flushTimer); s.flushTimer = null }
-  const pending = [...s.buffer.entries()]
-  s.buffer.clear()
-  for (const [eid, text] of pending) {
-    if (s.lastSent.get(eid) === text) continue
-    await streamText(cardId, eid, text)
-  }
-}
-
-/** Add a new element to the card body or relative to a sibling. */
-export function addElement(
-  cardId: string,
-  element: object,
-  opts: { type?: 'append' | 'insert_before' | 'insert_after'; targetElementId?: string } = {},
-): Promise<void> {
-  const s = state(cardId)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
-      await call('POST', `/cards/${cardId}/elements`, {
-        type: opts.type ?? 'append',
-        ...(opts.targetElementId ? { target_element_id: opts.targetElementId } : {}),
-        elements: JSON.stringify([element]),
-        sequence: seq,
-      })
-    } catch (e) { log(`cardkit addElement ${cardId}: ${e}`) }
-  })
-  return s.queue
-}
-
-/** Replace an entire element (used to swap a tool placeholder with its result). */
-export function replaceElement(cardId: string, elementId: string, element: object): Promise<void> {
-  const s = state(cardId)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
-      await call('PUT', `/cards/${cardId}/elements/${elementId}`, {
-        element: JSON.stringify(element),
-        sequence: seq,
-      })
-    } catch (e) { log(`cardkit replaceElement ${cardId}/${elementId}: ${e}`) }
-  })
-  return s.queue
-}
-
-/** Delete an element by id. */
-export function deleteElement(cardId: string, elementId: string): Promise<void> {
-  const s = state(cardId)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
-      await call('DELETE', `/cards/${cardId}/elements/${elementId}`, {
-        sequence: seq,
-      })
-    } catch (e) { log(`cardkit deleteElement ${cardId}/${elementId}: ${e}`) }
-  })
-  return s.queue
-}
-
-/** Patch settings — used to flip streaming_mode off when a turn finishes. */
-export function patchSettings(cardId: string, settings: object): Promise<void> {
-  const s = state(cardId)
-  const seq = nextSeq(cardId)
-  s.queue = s.queue.then(async () => {
-    try {
-      await call('PATCH', `/cards/${cardId}/settings`, {
-        settings: JSON.stringify(settings),
-        sequence: seq,
-      })
-    } catch (e) { log(`cardkit patchSettings ${cardId}: ${e}`) }
-  })
-  return s.queue
-}
-
-/** Drop in-memory bookkeeping for a finished card. */
-export async function dispose(cardId: string): Promise<void> {
-  const s = cards.get(cardId)
-  if (!s) return
-  await flush(cardId)
-  await s.queue
-  cards.delete(cardId)
-}

package/src/cards.ts

@@ -1,304 +0,0 @@
-/**
- * Schema 2.0 Feishu card templates.
- *
- * 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}`,
-} as const
-
-/** 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
-  switch (name) {
-    case 'Bash':       return truncate(String(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 ''
-}
-
-interface MainCardOpts {
-  sessionName: string
-  turn: number
-  model?: string
-  effort?: string
-  userText: string
-}
-
-/** Initial card sent at the start of each turn. Streaming on. */
-export function mainConversationCard(_opts: MainCardOpts): object {
-  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.
-      elements: [
-        { 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. */
-export function toolCallElement(
-  i: number,
-  name: string,
-  input: any,
-  output: string | null,
-  status: '⏳' | '✅' | '❌' = '⏳',
-): object {
-  const summary = summarizeToolInput(name, input)
-  const headerText = summary
-    ? `${status} 🔧 ${name}: ${summary}`
-    : `${status} 🔧 ${name}`
-  const inputBlock = '```\n' + JSON.stringify(input ?? {}, null, 2).slice(0, 2000) + '\n```'
-  const outputBlock = 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: inputBlock + outputBlock },
-    ],
-  }
-}
-
-interface PermissionOpts {
-  sessionName: string
-  toolName: string
-  description: string
-  inputPreview: string
-  requestId: string
-}
-
-export function permissionCard(opts: PermissionOpts): object {
-  const { sessionName, toolName, description, inputPreview, requestId } = opts
-  let pretty = inputPreview
-  try { pretty = JSON.stringify(JSON.parse(inputPreview), null, 2) } catch {}
-  return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: `🔐 权限请求 · ${toolName}` },
-      subtitle: { tag: 'plain_text', content: sessionName },
-      template: 'orange',
-    },
-    body: {
-      elements: [
-        { tag: 'markdown', content: description },
-        { tag: 'markdown', content: '```\n' + pretty.slice(0, 2000) + '\n```' },
-        {
-          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 } }],
-    }],
-  }
-}
-
-export function permissionResolvedCard(
-  toolName: string,
-  decision: 'allow' | 'allow_always' | 'deny',
-  user: string,
-): object {
-  const ok = decision !== 'deny'
-  const label = decision === 'allow_always' ? '始终允许' : decision === 'allow' ? '已允许' : '已拒绝'
-  return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: `🔐 权限请求 · ${toolName}` },
-      template: ok ? 'green' : 'red',
-    },
-    body: {
-      elements: [{
-        tag: 'markdown',
-        content: `${ok ? '✅' : '❌'} **${label}** by ${user || '匿名'} · ${new Date().toLocaleTimeString('zh-CN', { hour12: false })}`,
-      }],
-    },
-  }
-}
-
-interface ConsoleOpts {
-  sessionName: string
-  status: 'idle' | 'working' | 'awaiting_permission' | 'starting' | 'stopped'
-  model?: string
-  effort?: string
-  uptime?: string
-  lastActivity?: string
-  hasSession: boolean
-}
-
-export function consoleCard(opts: ConsoleOpts): object {
-  const { sessionName, status, model, effort, uptime, lastActivity, hasSession } = opts
-  const statusEmoji = {
-    idle: '🟢 闲', working: '⚙️ 工作中', awaiting_permission: '🔐 等审批',
-    starting: '🚀 启动中', stopped: '⚪ 未运行',
-  }[status]
-  const meta = [
-    `状态: ${statusEmoji}`,
-    model ? `模型: ${model}${effort ? `/${effort}` : ''}` : null,
-    uptime ? `运行: ${uptime}` : null,
-    lastActivity ? `最近: ${lastActivity}` : null,
-  ].filter(Boolean).join(' · ')
-
-  const buttons: [string, string, string][] = hasSession
-    ? [
-        ['⏸ 中断', 'interrupt', 'default'],
-        ['🧹 /clear', 'clear', 'default'],
-        ['⏹ 终止', 'stop', 'danger'],
-        ['📁 ls', 'ls', 'default'],
-      ]
-    : [
-        ['🚀 启动', 'start', 'primary'],
-        ['🔁 续聊', 'resume', 'default'],
-        ['📁 ls', 'ls', 'default'],
-      ]
-
-  const template = status === 'working' ? 'blue'
-    : status === 'awaiting_permission' ? 'orange'
-    : status === 'stopped' ? 'grey'
-    : 'green'
-
-  return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: `🌟 Lodestar · ${sessionName}` },
-      template,
-    },
-    body: {
-      elements: [
-        { tag: 'markdown', content: meta || '_(no state)_' },
-        {
-          tag: 'column_set',
-          columns: buttons.map(([label, action, kind]) => ({
-            tag: 'column', width: 'weighted', weight: 1,
-            elements: [{
-              tag: 'button',
-              text: { tag: 'plain_text', content: label },
-              type: kind,
-              behaviors: [{ type: 'callback', value: { kind: 'console', action } }],
-            }],
-          })),
-        },
-      ],
-    },
-  }
-}
-
-interface MenuOpts {
-  question: string
-  options: string[]
-  requestId: string
-}
-
-export function menuCard(opts: MenuOpts): object {
-  const { question, options, requestId } = opts
-  return {
-    schema: '2.0',
-    config: { update_multi: true },
-    header: {
-      title: { tag: 'plain_text', content: '📋 等待选择' },
-      template: 'turquoise',
-    },
-    body: {
-      elements: [
-        { tag: 'markdown', content: question || '_请选择一项：_' },
-        ...options.map((opt, i) => ({
-          tag: 'button',
-          text: { tag: 'plain_text', content: opt },
-          type: 'default',
-          behaviors: [{ type: 'callback', value: { kind: 'menu', request_id: requestId, choice: i } }],
-        })),
-      ],
-    },
-  }
-}
-
-export const STREAMING_OFF_SETTINGS = {
-  config: { streaming_mode: false, summary: { content: '✅ Lodestar 完成' } },
-}