Ordo UI
AI助手与对话

AnchorQaThread

@mox-hub/patterns · AI · 助手与对话 · canonical

anchor-qa-thread@mox-hub/patternsAI Executioncanonicalsrc/components/anchor-qa-thread.tsx
变体演示anchor-qa-thread

Props API

Prop类型默认值说明
onAsk*(question: string) => Promise<AnchorQaResult>——
onApplyAction*(action: AnchorQaAction) => Promise<void>——
onEscalatePanel*(draft: string) => void——
onEscalateOffice*() => void——
onOpenChange*(open: boolean) => void——
renderMarkdown*(content: string) => ReactNode(content) => <span className="whitespace-pre-wrap">{content}</span>—
translate*PatternTranslate——

源码

packages/patterns/src/components/anchor-qa-thread.tsx
/**
 * 行内锚点问答线程(候选 B 试点 · 任务详情页):
 * 「就地展开 > 弹层」——下沉展开行不遮邻居;提示=承诺兑现速度(silent 快捷问答)。
 *
 * 库内是纯展示件:问答请求、结果、动作落库、升级出口全部由 props 注入;
 * ordo 侧保留 useAnchorQa / store / router 的薄适配层。
 */
import { useEffect, useRef, useState, type ReactNode } from 'react'
import { ArrowUpRight, Check, DoorOpen, Send, Sparkles, X } from 'lucide-react'
import { cn } from '@mox-hub/ui'
import { Button } from '@mox-hub/ui/components/button'
import { Input } from '@mox-hub/ui/components/input'
import { type PatternTranslate } from '../lib/translate'
import { usePatternTranslate } from '../lib/i18n'

export interface AnchorQaAction {
  action: string
  label: string
}

export interface AnchorQaResult {
  answer: string
  actions?: AnchorQaAction[]
}

export interface QaEntry {
  question: string
  result: AnchorQaResult
  appliedActions: string[]
}

const ANCHOR_QA_LABELS: Record<string, string> = {
  'assistant.anchorQa.open': '问 AI',
  'assistant.anchorQa.placeholder': '就此任务问点什么…',
  'assistant.anchorQa.send': '发送',
  'assistant.anchorQa.thinking': '小周正在查看这个任务…',
  'assistant.anchorQa.failed': '回答失败,请重试',
  'assistant.anchorQa.applied': '已应用',
  'assistant.anchorQa.escalatePanel': '让我细聊',
  'assistant.anchorQa.escalateOffice': '进办公室',
  'assistant.anchorQa.escalateDraft':
    '刚才就「{{question}}」你回答过:{{answer}}。我想继续深入聊聊。',
  'assistant.anchorQa.escalatePlain': '想继续深入聊聊这个任务。',
  'common.close': '关闭',
}


export interface AnchorQaThreadProps {
  /** 提问回调:返回答案与可落库动作 */
  onAsk: (question: string) => Promise<AnchorQaResult>
  /** 动作就地落库;不传则动作键禁用 */
  onApplyAction?: (action: AnchorQaAction) => Promise<void>
  /** 升级到面板(draft 为带入的问答语境) */
  onEscalatePanel: (draft: string) => void
  /** 升级到办公室 */
  onEscalateOffice: () => void
  /** 关闭(父级控制展开态) */
  onOpenChange?: (open: boolean) => void
  /** 答案 Markdown 渲染器;缺省纯文本 */
  renderMarkdown?: (content: string) => ReactNode
  /** 文案覆写(默认 zh-CN;主仓 i18n 适配层集中传入 t() 包装)。 */
  translate?: PatternTranslate
}

export function AnchorQaThread({
  onAsk,
  onApplyAction,
  onEscalatePanel,
  onEscalateOffice,
  onOpenChange,
  renderMarkdown = (content) => <span className="whitespace-pre-wrap">{content}</span>,
  translate,
}: AnchorQaThreadProps) {
  const providerT = usePatternTranslate('anchorQaThread', ANCHOR_QA_LABELS)
  const t = translate ?? providerT
  const inputRef = useRef<HTMLInputElement>(null)
  const [question, setQuestion] = useState('')
  const [entries, setEntries] = useState<QaEntry[]>([])
  const [applying, setApplying] = useState<string | null>(null)
  const [pending, setPending] = useState(false)
  const [failed, setFailed] = useState(false)

  // 自动聚焦;开合由父级单向控制。
  useEffect(() => {
    inputRef.current?.focus()
  }, [])

  const ask = async () => {
    const trimmed = question.trim()
    if (!trimmed || pending) return
    setQuestion('')
    setPending(true)
    setFailed(false)
    try {
      const result = await onAsk(trimmed)
      setEntries((prev) => [...prev, { question: trimmed, result, appliedActions: [] }])
    } catch {
      setFailed(true)
      setQuestion(trimmed)
    } finally {
      setPending(false)
    }
  }

  const applyAction = async (entryIndex: number, action: AnchorQaAction) => {
    if (!onApplyAction || applying) return
    setApplying(`${entryIndex}:${action.action}`)
    try {
      await onApplyAction(action)
      setEntries((prev) =>
        prev.map((entry, i) =>
          i === entryIndex
            ? { ...entry, appliedActions: [...entry.appliedActions, action.action] }
            : entry,
        ),
      )
    } finally {
      setApplying(null)
    }
  }

  const escalateToPanel = () => {
    const last = entries[entries.length - 1]
    const draft = last
      ? t('assistant.anchorQa.escalateDraft', {
          question: last.question,
          answer: last.result.answer,
        })
      : t('assistant.anchorQa.escalatePlain')
    onEscalatePanel(draft)
  }

  return (
    <div
      className="mx-1 mt-1 rounded-lg border border-accent-purple/20 bg-accent-purple/5 p-2"
      data-ai-component="assistant.anchor-qa-thread"
      data-ai-role="panel"
      onKeyDown={(event) => {
        if (event.key === 'Escape') onOpenChange?.(false)
      }}
    >
      {entries.map((entry, index) => (
        <div
          key={index}
          className="mb-2 border-b border-border/60 pb-2 last:mb-0 last:border-0 last:pb-0"
        >
          <p className="truncate text-2xs font-medium text-content-text" title={entry.question}>
            {entry.question}
          </p>
          <div className="mt-1 text-xs leading-relaxed text-content-text">
            {renderMarkdown(entry.result.answer)}
          </div>
          {entry.result.actions && entry.result.actions.length > 0 && (
            <div className="mt-1.5 flex flex-wrap items-center gap-1.5">
              {entry.result.actions.map((action) => {
                const applied = entry.appliedActions.includes(action.action)
                return (
                  <Button
                    key={action.action}
                    variant="outline"
                    size="sm"
                    className="h-6 px-2 text-2xs"
                    disabled={applied || applying !== null || !onApplyAction}
                    onClick={() => applyAction(index, action)}
                    data-ai-action="assistant.anchor-qa.apply.click"
                  >
                    {applied ? (
                      <Check className="size-3 text-accent-green" />
                    ) : (
                      <Sparkles className="size-3 text-accent-purple" />
                    )}
                    {applied ? t('assistant.anchorQa.applied') : action.label}
                  </Button>
                )
              })}
            </div>
          )}
        </div>
      ))}

      {pending && (
        <p className="mb-2 animate-pulse text-2xs text-accent-purple">
          {t('assistant.anchorQa.thinking')}
        </p>
      )}
      {failed && (
        <p className="mb-2 text-2xs text-accent-red">{t('assistant.anchorQa.failed')}</p>
      )}

      <div className="flex items-center gap-1.5">
        <Input
          ref={inputRef}
          value={question}
          onChange={(event) => setQuestion(event.target.value)}
          onKeyDown={(event) => {
            if (event.key === 'Enter' && !event.nativeEvent.isComposing) ask()
          }}
          placeholder={t('assistant.anchorQa.placeholder')}
          className="h-7 border-0 bg-transparent text-xs shadow-none focus-visible:ring-2 focus-visible:ring-ring/50"
          data-ai-component="assistant.anchor-qa-input"
          data-ai-role="input"
        />
        <Button
          variant="ghost"
          size="sm"
          className="h-6 w-6 shrink-0 p-0"
          disabled={!question.trim() || pending}
          onClick={ask}
          data-ai-action="assistant.anchor-qa.send.click"
          aria-label={t('assistant.anchorQa.send')}
        >
          <Send className="size-3.5" />
        </Button>
        <Button
          variant="ghost"
          size="sm"
          className="h-6 w-6 shrink-0 p-0"
          onClick={() => onOpenChange?.(false)}
          aria-label={t('common.close')}
        >
          <X className="size-3.5" />
        </Button>
      </div>

      <div className="mt-1 flex items-center gap-3 border-t border-border/60 pt-1.5">
        <button
          type="button"
          onClick={escalateToPanel}
          className="flex cursor-pointer items-center gap-1 text-2xs text-accent-purple transition-opacity hover:opacity-80"
          data-ai-action="assistant.anchor-qa.escalate-panel.click"
        >
          <ArrowUpRight className="size-3" />
          {t('assistant.anchorQa.escalatePanel')}
        </button>
        <button
          type="button"
          onClick={onEscalateOffice}
          className="flex cursor-pointer items-center gap-1 text-2xs text-content-text-muted transition-opacity hover:opacity-80"
          data-ai-action="assistant.anchor-qa.escalate-office.click"
        >
          <DoorOpen className="size-3" />
          {t('assistant.anchorQa.escalateOffice')}
        </button>
      </div>
    </div>
  )
}

/** 幽灵暗示按钮(渐进披露②):hover/聚焦才显形,低饱和不遮内容 */
export function AnchorQaGhostButton({
  open,
  onClick,
  label,
}: {
  open: boolean
  onClick: () => void
  label?: string
}) {
  const t = usePatternTranslate('anchorQaThread', ANCHOR_QA_LABELS)
  return (
    <button
      type="button"
      onClick={onClick}
      className={cn(
        'flex h-7 items-center gap-1 rounded-full px-2 text-2xs text-accent-purple/70 transition-opacity',
        'opacity-0 group-hover/sidebar:opacity-100 focus-visible:opacity-100',
        'hover:bg-accent-purple/10 hover:text-accent-purple',
        open && 'opacity-100 bg-accent-purple/10 text-accent-purple',
      )}
      data-ai-component="assistant.anchor-qa-ghost"
      data-ai-action="assistant.anchor-qa.open.click"
    >
      <Sparkles className="size-3" />
      {label ?? t('assistant.anchorQa.open')}
    </button>
  )
}

可访问性与 RTL

  • 键盘:交互件保留:focus-visible焦点环;浮层支持 Escape 关闭与焦点归还,菜单 / 页签按 Base UI 约定支持方向键。 筛选菜单、拖拽排序、执行树与模型 listbox 等关键键盘流由 Playwright 断言覆盖,见规范示例 · 交互与可访问性。
  • RTL:间距、对齐与方向性图标使用逻辑属性 (ms-* /text-start /rtl:-scale-x-100);通过 ThemeProvider 或I18nProvider 的direction="rtl"驱动,`lint:rtl` 会拦截新增物理类。
  • 文案:优先用组件labels /translate /translator props,其次用I18nProvider目录;内置 zh-CN 默认值,en-US 为参考翻译。见Theming · i18n 与 RTL。
  • 对比度:高对比度 token、2px 控件边框与 3px 焦点环由主题层统一提供,见Foundations · Contrast。

用法说明

行内锚点问答线程:就地展开、动作贴答案、必有升级出口;onAsk/onApplyAction/升级回调由消费方注入。