mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-16 22:22:00 +00:00
12dc47b976
检查器 - 「要审的报告」留空时,照服务端 schema.challenge_report 的认法:先看直接连着的报告撰写节点,恰好一个就审它;不是一个时,整个上游只有一个才取那一个。以前只认第二步,「初稿 → 终稿 → 反方审稿」这种接法下会误报「上游有 2 个,请选择」,同模型提醒也不出。现在留空项写出实际会审的那份(「未选择:审上游的「终稿」」),同模型提醒也按同一套认法判断。 - 认法写成 nodePickField / upstreamModel 的 rule 选项。缺省是 'upstream'(只看整个上游),和 F1a 的 dual_check_card 一致,双盲复算以后也能直接用。 - 选中的节点在上游、类型却不对(例如输入节点),以前写成「不在上游」,现在照实写「不是报告撰写节点」,提示里说清它是哪类节点。判断顺序和服务端一致:先看存不存在,再看类型,最后看在不在上游。 - 画布校验已经在 report / model 字段上报过问题时,不再画本地那句提示,避免同一件事一琥珀一红说两遍。判断哪些问题属于本字段,用和 Inspector 挂字段时相同的 fieldOfIssue;下拉里照实标出的那一项保留。 - 文案里的设置入口统一写成「设置 → 偏好设置 → 核查」,和设置页的真实标签、双盲复算、证据裁判的写法一致。 审批卡 - 降档的原因改为常显在概况下面,不再只放在悬停提示和读屏文字里。 - 运行类别取不到时,不再悄悄不写降档:照实写「暂时无法确认运行类别;如为正式运行,被推翻的结论会使出具降档」,并给出重试按钮;窗口重新拿到焦点时也会再取一次。 - 「显示全部」补句时按 unit 去重:两边都有 unit 时只比 unit,有一边缺 unit 才比原文。以前原文相同、unit 不同的一句会被吞掉,被吞的可能正是被推翻的那句。条目缺 unit 时不再补假的 #i。 - 键盘按「显示全部」、补句那一行的重试、一句详情里的重试、运行类别的重试之后,焦点都会接到新出现的内容上,不再掉到 body。焦点已经被用户移到别处时不抢。 - 审稿记录没存上(artifact 为 null)时,每句只列判断,不能点开,整块说一句「反方审稿记录未保存,无法查看理由和查询」;「另有 N 句未列出」照常显示,只是不给「显示全部」。 检查(check-challenge 共 153 项) - 新增预览用例:正式运行且没有被推翻的结论(降档 / 只标注)、探索运行配只标注、运行类别取不到、原文相同而 unit 不同、审稿记录没存上、链式接法的检查器。 - 「只标注、探索运行、没有反方审稿」拆成各自独立的段,一段出错不会遮住其余几段。 - 新增的检查项包括:降档原因常显、取不到运行类别时的说明和重试(含窗口重新拿到焦点后再取)、显示全部和各处重试后的焦点、按 unit 去重、审稿记录没存上、链式接法、类型不对的节点、校验报过就不重复说,以及窄屏和深浅色下新增几行说明的对比度。 - 复核时用来证明检查不够的两个变异,M1(正式运行一律写降档)和 M10(探索运行也写只标注说明),连同本次各项修正的变异,都已逐一确认会被检查发现。
659 lines
34 KiB
TypeScript
659 lines
34 KiB
TypeScript
import { Fragment, useCallback, useEffect, useId, useMemo, useRef, useState, type CSSProperties, type ReactNode } from 'react'
|
||
import { AlertTriangle, ChevronRight, ShieldAlert } from 'lucide-react'
|
||
import { api } from '../api/client'
|
||
import { EVIDENCE_STATE, segmentLabel, segmentState, sourceOf, unitText, type EvidenceStateCode } from '../lib/evidence'
|
||
import { CHALLENGE_TEXT, EVIDENCE_STATE_LABEL, EVIDENCE_TEXT } from '../lib/terms'
|
||
import { asDoc, useEvidence } from '../store/evidence'
|
||
import type {
|
||
ApprovalChallenge, ApprovalReport, ChallengeArtifact, ChallengeClaim, ChallengeCounts, ChallengeItem, ChallengeQuery,
|
||
ChallengeVerdict, EvidenceBlock, EvidenceDocData, EvidenceSegment, EvidenceUnit,
|
||
} from '../types'
|
||
import { BlockView, CopyChip, Markdown, StyledSlice, inlineStyles, numericColumns } from './Markdown'
|
||
|
||
export interface ChallengeSummaryProps {
|
||
/** 这张审批卡审的报告(payload.reports,和 ApprovalReports 拿到的是同一份) */
|
||
reports: ApprovalReport[]
|
||
runId: string
|
||
}
|
||
|
||
/**
|
||
* 审批卡里反方审稿的摘要,紧跟在报告核对概况(ApprovalReports)后面:一行概况(四种判断各几句),逐句列出结论原文和判断,
|
||
* 点开一句再按 challenge_artifact 取完整内容,看反方的理由和它执行过的查询。审稿记录没存上(没有工件)时只列判断、
|
||
* 不能点开,整块说一次。
|
||
*
|
||
* 判断是反方模型给的,不是系统核对:颜色照结论句裁判的那一套,「经受住」也不用确定性的绿。
|
||
* 「出具会降档」只在正式运行、有被推翻的结论、按降档处理时才写——只标注的不写降档,探索运行不出具,和出具有关的话一句不说。
|
||
* 运行类别不由审批卡传进来,按运行 id 从证据 store 取(loadRunClass),取到之前不说;取不到时照实说取不到,可重试。
|
||
*
|
||
* 审的报告都没有经过反方审稿时什么都不画,也不发任何请求,卡片和以前一样。
|
||
*/
|
||
export function ChallengeSummary({ reports, runId }: ChallengeSummaryProps) {
|
||
const reviewed = useMemo(() => reports.flatMap((r) => {
|
||
const challenge = challengeOf(r)
|
||
return challenge ? [{ report: r, challenge }] : []
|
||
}), [reports])
|
||
if (!reviewed.length) return null
|
||
return <ChallengeList reviewed={reviewed} runId={runId} />
|
||
}
|
||
|
||
function ChallengeList({ reviewed, runId }: {
|
||
reviewed: { report: ApprovalReport; challenge: ApprovalChallenge }[]; runId: string
|
||
}) {
|
||
const run = useRunClass(runId)
|
||
return (
|
||
<>
|
||
{reviewed.map(({ report, challenge }) => (
|
||
<ChallengeBlock key={report.node_id} report={report} challenge={challenge} run={run} />
|
||
))}
|
||
</>
|
||
)
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 认 payload
|
||
|
||
const VERDICTS: readonly ChallengeVerdict[] = ['stands', 'weakened', 'refuted', 'inconclusive']
|
||
const isVerdict = (v: unknown): v is ChallengeVerdict => typeof v === 'string' && (VERDICTS as readonly string[]).includes(v)
|
||
|
||
/** 颜色同结论句裁判(lib/evidence 的 EVIDENCE_STATE):经受住同「有依据」,被削弱同「部分有依据」,被推翻同「证据相矛盾」 */
|
||
const VERDICT_COLOR: Record<ChallengeVerdict, string> = {
|
||
stands: 'var(--st-running)',
|
||
weakened: 'var(--st-waiting)',
|
||
refuted: 'var(--st-failed)',
|
||
inconclusive: 'var(--st-cancelled)',
|
||
}
|
||
|
||
const verdictLabel = (v: string) => (isVerdict(v) ? CHALLENGE_TEXT.verdict[v] : CHALLENGE_TEXT.verdictUnknown(v))
|
||
|
||
function isItem(x: unknown): x is ChallengeItem {
|
||
return !!x && typeof x === 'object' && typeof (x as ChallengeItem).text === 'string' && typeof (x as ChallengeItem).verdict === 'string'
|
||
}
|
||
|
||
const count = (v: unknown) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0)
|
||
|
||
/**
|
||
* payload.reports[i].challenge 认不认得:要么有计数、要么有条目。计数缺了按条目数(条目最多 10 条,计数才是全部);
|
||
* 条目缺了 unit 的留空(行的键带序号,区分得开),不补假的:补出来的键会被当成真的 unit 去和工件里的句子比
|
||
*/
|
||
function challengeOf(report: ApprovalReport): ApprovalChallenge | null {
|
||
const raw = report.challenge as unknown
|
||
if (!raw || typeof raw !== 'object') return null
|
||
const c = raw as Record<string, unknown>
|
||
const items = (Array.isArray(c.items) ? c.items.filter(isItem) : [])
|
||
.map((it) => ({ unit: typeof it.unit === 'string' ? it.unit : '', text: it.text, verdict: it.verdict }))
|
||
// 计数里一个数都没有(格式不对)也按条目数,免得概况写四个 0、下面却列着几句
|
||
const given = c.counts && typeof c.counts === 'object' && VERDICTS.some((v) => typeof (c.counts as any)[v] === 'number')
|
||
? c.counts as Record<string, unknown> : null
|
||
const counts = Object.fromEntries(VERDICTS.map((v) => [v, given
|
||
? count(given[v]) : items.filter((it) => it.verdict === v).length])) as ChallengeCounts
|
||
if (!given && !items.length) return null
|
||
return {
|
||
counts, items, artifact: typeof c.artifact === 'string' && c.artifact ? c.artifact : null,
|
||
on_refuted: typeof c.on_refuted === 'string' ? c.on_refuted : undefined,
|
||
}
|
||
}
|
||
|
||
interface RunClass {
|
||
runClass: 'formal' | 'exploratory' | null
|
||
/** 取失败了、还没取到(重取期间也算:那一行和焦点所在的重试按钮不跟着闪掉) */
|
||
failed: boolean
|
||
retry: () => void
|
||
}
|
||
|
||
function useRunClass(runId: string): RunClass {
|
||
const slot = useEvidence((s) => (runId ? s.runClasses[runId] : undefined))
|
||
const load = useEvidence((s) => s.loadRunClass)
|
||
useEffect(() => { if (runId) void load(runId) }, [runId, load])
|
||
const status = slot?.status
|
||
const [hadError, setHadError] = useState(false)
|
||
useEffect(() => {
|
||
if (status === 'error') setHadError(true)
|
||
else if (status === 'ok') setHadError(false)
|
||
}, [status])
|
||
const failed = status === 'error' || (hadError && status === 'loading')
|
||
// 取失败了不就此作罢:窗口重新拿到焦点时再取一次(store 对出错的槽会重发)。只取一次就放弃的话,一次网络抖动
|
||
// 会让「出具会降档」一直不出现,而卡顶按审批自带的运行类别照样写着正式运行
|
||
useEffect(() => {
|
||
if (status !== 'error' || !runId) return
|
||
const again = () => { void load(runId) }
|
||
window.addEventListener('focus', again)
|
||
return () => window.removeEventListener('focus', again)
|
||
}, [status, runId, load])
|
||
const retry = useCallback(() => { if (runId) void load(runId) }, [runId, load])
|
||
const runClass = status === 'ok' && (slot?.data === 'formal' || slot?.data === 'exploratory') ? slot.data : null
|
||
return { runClass, failed, retry }
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 取工件
|
||
|
||
/** 工件 id → 取回的内容。工件内容寻址、不可变,取到的永久缓存;出错的不缓存成定论,下次点开再取 */
|
||
const fetched = new Map<string, Promise<ChallengeArtifact>>()
|
||
|
||
function loadChallenge(id: string): Promise<ChallengeArtifact> {
|
||
let pending = fetched.get(id)
|
||
if (!pending) {
|
||
pending = api.artifact(id).then((res) => {
|
||
const content = asChallenge(res?.content)
|
||
if (!content) throw new Error(CHALLENGE_TEXT.failed)
|
||
return content
|
||
})
|
||
pending.catch(() => { fetched.delete(id) })
|
||
fetched.set(id, pending)
|
||
}
|
||
return pending
|
||
}
|
||
|
||
const text = (v: unknown) => (typeof v === 'string' ? v : '')
|
||
|
||
function asQuery(x: unknown): ChallengeQuery | null {
|
||
if (!x || typeof x !== 'object') return null
|
||
const q = x as Record<string, unknown>
|
||
return {
|
||
alias: text(q.alias), artifact: text(q.artifact), sql: text(q.sql),
|
||
row_count: typeof q.row_count === 'number' && Number.isFinite(q.row_count) ? q.row_count : null,
|
||
truncated: q.truncated === true, source: typeof q.source === 'string' && q.source ? q.source : null,
|
||
}
|
||
}
|
||
|
||
/** 工件内容认不认得:至少得有 claims 列表;每一句缺的字段按空的补,界面照实少显示 */
|
||
function asChallenge(content: unknown): ChallengeArtifact | null {
|
||
if (!content || typeof content !== 'object' || !Array.isArray((content as ChallengeArtifact).claims)) return null
|
||
const c = content as Record<string, any>
|
||
const claims: ChallengeClaim[] = (c.claims as unknown[]).filter(isItem).map((it) => {
|
||
const raw = it as unknown as Record<string, unknown>
|
||
const doc = raw.rationale_doc
|
||
return {
|
||
unit: text(raw.unit), text: it.text, verdict: it.verdict, rationale: text(raw.rationale),
|
||
rationale_doc: typeof doc === 'string' || (doc && typeof doc === 'object') ? doc as ChallengeClaim['rationale_doc'] : null,
|
||
queries: (Array.isArray(raw.queries) ? raw.queries : []).map(asQuery).filter((q): q is ChallengeQuery => !!q),
|
||
}
|
||
})
|
||
return { report: text(c.report), doc_artifact: text(c.doc_artifact), claims, model: typeof c.model === 'string' && c.model ? c.model : null }
|
||
}
|
||
|
||
type Fetch = { status: 'idle' | 'loading' | 'ok' | 'error'; data?: ChallengeArtifact }
|
||
/** retry 没有时不给重试:审批里根本没带工件 id,再取也是一样 */
|
||
type Detail = Fetch & { retry?: () => void }
|
||
|
||
/** 整份反方审稿:want 为真(点开过一句、要看全部)之后才取,一张卡里各句共用这一次 */
|
||
function useChallengeArtifact(id: string, want: boolean): Detail {
|
||
const [state, setState] = useState<Fetch>({ status: 'idle' })
|
||
const [attempt, setAttempt] = useState(0)
|
||
useEffect(() => {
|
||
if (!want || !id) return
|
||
let alive = true
|
||
setState((s) => (s.status === 'ok' ? s : { status: 'loading' }))
|
||
loadChallenge(id).then(
|
||
(data) => { if (alive) setState({ status: 'ok', data }) },
|
||
() => { if (alive) setState({ status: 'error' }) },
|
||
)
|
||
return () => { alive = false }
|
||
}, [id, want, attempt])
|
||
const retry = useCallback(() => setAttempt((n) => n + 1), [])
|
||
return id ? { ...state, retry } : { status: 'error' }
|
||
}
|
||
|
||
/**
|
||
* 工件里的一句和审批条目里的一句是不是同一句:两边都有 unit 时只按 unit 认——同一句话在摘要和正文各出现一次、各自被挑来审,
|
||
* 原文一样、unit 不同,是两句(按原文认会把其中一句吞掉,被吞的可能正是被推翻的那句);有一边没给 unit(老服务端)才按原文认
|
||
*/
|
||
const sameClaim = (a: ChallengeItem, b: ChallengeItem) => (a.unit && b.unit ? a.unit === b.unit : a.text === b.text)
|
||
|
||
/** 这一句在工件里的完整内容 */
|
||
function claimOf(artifact: ChallengeArtifact | undefined, item: ChallengeItem): ChallengeClaim | undefined {
|
||
return artifact?.claims.find((c) => sameClaim(c, item))
|
||
}
|
||
|
||
/** 补齐、重试之后接住焦点的几处:本身不在 Tab 顺序里(tabIndex -1),键盘用户得看得见焦点落在哪 */
|
||
const FOCUS_RING = 'rounded-sm focus:outline-none focus-visible:outline focus-visible:outline-solid focus-visible:outline-2 '
|
||
+ 'focus-visible:outline-offset-1 focus-visible:outline-[color:var(--accent)]'
|
||
|
||
/** 焦点丢了(按过的按钮被拿掉,落回 body)才替它接住;取的这一会儿用户已经去了别处的,不抢 */
|
||
const focusLost = () => !document.activeElement || document.activeElement === document.body
|
||
|
||
// ---------------------------------------------------------------- 卡片
|
||
|
||
function ChallengeBlock({ report, challenge, run }: {
|
||
report: ApprovalReport; challenge: ApprovalChallenge; run: RunClass
|
||
}) {
|
||
const [open, setOpen] = useState<Set<string>>(() => new Set())
|
||
const [all, setAll] = useState(false)
|
||
const detail = useChallengeArtifact(challenge.artifact ?? '', all || open.size > 0)
|
||
const { counts, items } = challenge
|
||
const total = VERDICTS.reduce((n, v) => n + counts[v], 0)
|
||
// 审批里没带工件:服务端保存审稿记录失败了。每句都看不了理由和查询,不画成能点开的样子,整块说一次
|
||
const noRecord = !challenge.artifact
|
||
const refuted = counts.refuted > 0 && run.runClass === 'formal'
|
||
// 没给 on_refuted(老服务端)按降档;报错的节点到不了审批,不会是 fail
|
||
const flagged = challenge.on_refuted === 'flag'
|
||
// 条目之外的几句(条目最多 10 条):要看全部时从工件里补上,排在后面,顺序照工件
|
||
const extra = all && detail.data ? detail.data.claims.filter((c) => !items.some((it) => sameClaim(c, it))) : []
|
||
const rows: ChallengeItem[] = [...items, ...extra]
|
||
const hidden = Math.max(0, total - items.length)
|
||
const toggle = (key: string) => setOpen((cur) => {
|
||
const next = new Set(cur)
|
||
if (next.has(key)) next.delete(key)
|
||
else next.add(key)
|
||
return next
|
||
})
|
||
|
||
// 「显示全部」那一行补齐后整行拿掉、取的时候按钮也停用,焦点会掉到页面上,下一个 Tab 就跳过了新补出来的几句:
|
||
// 按过「显示全部」或那一行的「重试」之后,取到了落到补出来的第一句上(计数和工件对不上、什么也没补到时落到最后一句),
|
||
// 又没取到落到那一行新出现的「重试」上
|
||
const blockRef = useRef<HTMLDivElement>(null)
|
||
const moreRef = useRef<HTMLDivElement>(null)
|
||
const focusMore = useRef(false)
|
||
useEffect(() => {
|
||
if (!focusMore.current || !all || (detail.status !== 'ok' && detail.status !== 'error')) return
|
||
focusMore.current = false
|
||
if (!focusLost()) return
|
||
if (detail.status === 'error') {
|
||
moreRef.current?.querySelector<HTMLElement>('button')?.focus()
|
||
return
|
||
}
|
||
const toggles = blockRef.current?.querySelectorAll<HTMLElement>('[data-challenge-toggle]')
|
||
;(toggles?.[items.length] ?? toggles?.[toggles.length - 1])?.focus()
|
||
}, [all, detail.status, items.length])
|
||
const showAll = () => { focusMore.current = true; setAll(true) }
|
||
const retryAll = () => { focusMore.current = true; detail.retry?.() }
|
||
|
||
// 运行类别重取成功后,「暂时无法确认」那一行(连同焦点所在的重试按钮)换成降档说明:焦点接到概况那一行上
|
||
const countsRef = useRef<HTMLDivElement>(null)
|
||
const runRetried = useRef(false)
|
||
useEffect(() => {
|
||
if (run.failed || !runRetried.current) return
|
||
runRetried.current = false
|
||
if (focusLost()) countsRef.current?.focus()
|
||
}, [run.failed])
|
||
const retryRun = () => { runRetried.current = true; run.retry() }
|
||
|
||
return (
|
||
<div ref={blockRef} className="mb-2 rounded border bg-bg p-2" data-challenge={report.node_id}>
|
||
<div className="mb-1 flex items-center gap-1 text-2xs font-medium text-faint">
|
||
<ShieldAlert size={11} aria-hidden /> {CHALLENGE_TEXT.head(report.label || report.node_id)}
|
||
</div>
|
||
{total > 0 || items.length ? (
|
||
<div ref={countsRef} tabIndex={-1} className={`tnum flex flex-wrap items-center gap-x-1.5 gap-y-1 text-2xs ${FOCUS_RING}`}
|
||
data-challenge-counts="">
|
||
{VERDICTS.map((v, i) => (
|
||
<Fragment key={v}>
|
||
{i > 0 && <span className="text-faint" aria-hidden>·</span>}
|
||
<span data-challenge-count={v} style={{ color: counts[v] ? VERDICT_COLOR[v] : 'var(--text-faint)' }}>
|
||
{CHALLENGE_TEXT.count(CHALLENGE_TEXT.verdict[v], counts[v])}
|
||
</span>
|
||
</Fragment>
|
||
))}
|
||
{refuted && !flagged && (
|
||
<span className="chip shrink-0 font-semibold" data-challenge-degrade=""
|
||
style={{ color: 'var(--st-failed)', borderColor: 'var(--st-failed)' }}>
|
||
<AlertTriangle size={11} aria-hidden /> {CHALLENGE_TEXT.degrade}
|
||
</span>
|
||
)}
|
||
</div>
|
||
) : (
|
||
<div className="text-2xs text-dim" data-challenge-empty="">{CHALLENGE_TEXT.none}</div>
|
||
)}
|
||
{/* 降档的原因常显,不放在悬停提示里:触屏、键盘用户也得看得到为什么、会怎样(只标注那一档同样常显一行) */}
|
||
{refuted && !flagged && (
|
||
<div className="mt-0.5 text-2xs leading-relaxed text-dim" data-challenge-degrade-note="">{CHALLENGE_TEXT.degradeHint}</div>
|
||
)}
|
||
{refuted && flagged && (
|
||
<div className="mt-0.5 text-2xs leading-relaxed text-dim" data-challenge-flag="">{CHALLENGE_TEXT.flagNote}</div>
|
||
)}
|
||
{/* 运行类别取不到:不知道是不是正式运行,不能装作没事(卡顶按审批自带的运行类别照样写着正式运行),照实说并可重试 */}
|
||
{counts.refuted > 0 && !flagged && run.failed && (
|
||
<div className="mt-0.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-2xs leading-relaxed" data-challenge-runclass="failed">
|
||
<span style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.runClassFailed}</span>
|
||
<button type="button" className="btn btn-xs" onClick={retryRun}>{CHALLENGE_TEXT.retry}</button>
|
||
</div>
|
||
)}
|
||
{rows.length > 0 && (
|
||
<ul className="mt-1.5 space-y-0.5" data-challenge-items="">
|
||
{rows.map((item, i) => {
|
||
const key = `${item.unit}\u0000${i}`
|
||
if (noRecord) {
|
||
return (
|
||
<li key={key} data-challenge-item={item.unit} data-challenge-verdict={item.verdict}
|
||
className="flex min-w-0 items-start gap-1.5 px-1 py-0.5 text-2xs leading-relaxed">
|
||
<ClaimLine item={item} />
|
||
</li>
|
||
)
|
||
}
|
||
return (
|
||
<ClaimRow key={key} item={item} open={open.has(key)} onToggle={() => toggle(key)}>
|
||
<ClaimDetail item={item} detail={detail} />
|
||
</ClaimRow>
|
||
)
|
||
})}
|
||
</ul>
|
||
)}
|
||
{/* 工件取回来了、却没有条目之外的句子(计数和工件对不上):没什么可补的,这一行也不留。没有工件时照样交代
|
||
还有几句没列出,只是补不了 */}
|
||
{hidden > 0 && !extra.length && !(all && detail.status === 'ok') && (
|
||
<div ref={moreRef} className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-2xs text-dim" data-challenge-more={hidden}>
|
||
<span>{CHALLENGE_TEXT.more(hidden)}</span>
|
||
{noRecord ? null : detail.status === 'error' && all ? (
|
||
<>
|
||
<span style={{ color: 'var(--st-waiting)' }} role="alert">{CHALLENGE_TEXT.failed}</span>
|
||
{detail.retry && <button type="button" className="btn btn-xs" onClick={retryAll}>{CHALLENGE_TEXT.retry}</button>}
|
||
</>
|
||
) : (
|
||
<button type="button" className="btn btn-xs" disabled={all && detail.status === 'loading'}
|
||
data-challenge-show-all="" onClick={showAll}>
|
||
{all && detail.status === 'loading' ? CHALLENGE_TEXT.loading : CHALLENGE_TEXT.showAll}
|
||
</button>
|
||
)}
|
||
</div>
|
||
)}
|
||
{noRecord && (total > 0 || items.length > 0) && (
|
||
<div className="mt-1 text-2xs leading-relaxed" style={{ color: 'var(--st-waiting)' }} data-challenge-norecord="">
|
||
{CHALLENGE_TEXT.noRecord}
|
||
</div>
|
||
)}
|
||
{/* 判断标签看着像结论,得说清是谁判的:整块说一次,工件取回来之后带上模型名 */}
|
||
{(total > 0 || items.length > 0) && (
|
||
<p className="mt-1 text-2xs leading-relaxed text-faint" data-challenge-judged="">
|
||
{CHALLENGE_TEXT.judgedBy(detail.data?.model ?? null)}
|
||
</p>
|
||
)}
|
||
</div>
|
||
)
|
||
}
|
||
|
||
/** 判断标签:文字加颜色(去掉颜色也读得出),不铺底色——浅色主题下底色会把小字的对比度压到 4.5 以下 */
|
||
function VerdictTag({ verdict }: { verdict: string }) {
|
||
const color = isVerdict(verdict) ? VERDICT_COLOR[verdict] : 'var(--text-dim)'
|
||
return (
|
||
<span className="chip shrink-0 font-medium" data-challenge-tag={verdict}
|
||
style={{ color, borderColor: `color-mix(in srgb, ${color} 45%, transparent)` }}>
|
||
{verdictLabel(verdict)}
|
||
</span>
|
||
)
|
||
}
|
||
|
||
/** 一句的判断标签和结论原文 */
|
||
function ClaimLine({ item }: { item: ChallengeItem }) {
|
||
return (
|
||
<>
|
||
<VerdictTag verdict={item.verdict} />
|
||
{/* 原文取自报告文档,是 Markdown:粗体、行内代码照样画出来;链接不画成链接,按钮里不能再套一个可点的东西 */}
|
||
<span className="min-w-0 flex-1 [overflow-wrap:anywhere]" data-challenge-text="">
|
||
<StyledSlice text={item.text} styles={inlineStyles(item.text)} from={0} to={item.text.length} links={false} />
|
||
</span>
|
||
</>
|
||
)
|
||
}
|
||
|
||
function ClaimRow({ item, open, onToggle, children }: {
|
||
item: ChallengeItem; open: boolean; onToggle: () => void; children: ReactNode
|
||
}) {
|
||
const detailId = useId()
|
||
return (
|
||
<li data-challenge-item={item.unit} data-challenge-verdict={item.verdict}>
|
||
<button type="button" aria-expanded={open} aria-controls={open ? detailId : undefined} onClick={onToggle} data-challenge-toggle=""
|
||
className="flex w-full min-w-0 items-start gap-1.5 rounded px-1 py-0.5 text-left text-2xs leading-relaxed hover:bg-hover focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-[color:var(--accent)]">
|
||
<ChevronRight size={11} aria-hidden className="mt-[3px] shrink-0 text-faint"
|
||
style={{ transform: open ? 'rotate(90deg)' : 'none', transition: 'transform .15s' }} />
|
||
<ClaimLine item={item} />
|
||
</button>
|
||
{open && (
|
||
<div id={detailId} className="mb-1 ml-4 mt-1 min-w-0 space-y-2 rounded border p-2" data-challenge-detail={item.unit}>
|
||
{children}
|
||
</div>
|
||
)}
|
||
</li>
|
||
)
|
||
}
|
||
|
||
/** 点开的一句:工件取回来之前说正在加载;取不到给重试;取到了画理由和查询 */
|
||
function ClaimDetail({ item, detail }: { item: ChallengeItem; detail: Detail }) {
|
||
const baseId = useId()
|
||
const claim = claimOf(detail.data, item)
|
||
// 理由里的数字点一下:焦点落到那次查询上,描一下边(减少动效时也看得见)
|
||
const jump = useCallback((alias: string) => {
|
||
const part = document.getElementById(`${baseId}-q-${alias}`)
|
||
const head = part?.querySelector<HTMLElement>('[data-challenge-query-head]')
|
||
if (!part || !head) return
|
||
head.focus({ preventScroll: true })
|
||
head.scrollIntoView({ block: 'nearest' })
|
||
part.dataset.flash = 'focus'
|
||
setTimeout(() => { if (part.dataset.flash === 'focus') delete part.dataset.flash }, 1600)
|
||
}, [baseId])
|
||
// 点了「重试」,按钮在加载时就拿掉了:取到了焦点落到理由上,又没取到落到新的「重试」上,不掉到页面上
|
||
const retried = useRef(false)
|
||
const landing = useRef<HTMLElement | null>(null)
|
||
const land = useCallback((el: HTMLElement | null) => { landing.current = el }, [])
|
||
useEffect(() => {
|
||
if (!retried.current || (detail.status !== 'ok' && detail.status !== 'error')) return
|
||
retried.current = false
|
||
if (focusLost()) landing.current?.focus()
|
||
}, [detail.status])
|
||
if (detail.status === 'error') {
|
||
return (
|
||
<div className="flex flex-wrap items-center gap-2 text-2xs" data-challenge-detail-state="error">
|
||
<span role="alert" style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.failed}</span>
|
||
{detail.retry && (
|
||
<button ref={land} type="button" className="btn btn-xs"
|
||
onClick={() => { retried.current = true; detail.retry?.() }}>
|
||
{CHALLENGE_TEXT.retry}
|
||
</button>
|
||
)}
|
||
</div>
|
||
)
|
||
}
|
||
if (detail.status !== 'ok') {
|
||
return <div className="text-2xs text-faint" data-challenge-detail-state="loading">{CHALLENGE_TEXT.loading}</div>
|
||
}
|
||
if (!claim) {
|
||
return (
|
||
<div ref={land} tabIndex={-1} className={`text-2xs text-dim ${FOCUS_RING}`}
|
||
data-challenge-detail-state="missing">
|
||
{CHALLENGE_TEXT.claimMissing}
|
||
</div>
|
||
)
|
||
}
|
||
const aliases = new Set(claim.queries.map((q) => q.alias))
|
||
return (
|
||
<>
|
||
<section ref={land} tabIndex={-1} className={FOCUS_RING} data-challenge-detail-state="ok" data-challenge-rationale="">
|
||
<div className="mb-0.5 text-2xs font-medium text-faint">{CHALLENGE_TEXT.rationale}</div>
|
||
<Rationale claim={claim} onJump={(alias) => (aliases.has(alias) ? jump(alias) : undefined)} />
|
||
</section>
|
||
<section data-challenge-queries={claim.queries.length}>
|
||
<div className="mb-1 text-2xs font-medium text-faint">
|
||
{claim.queries.length ? CHALLENGE_TEXT.queries(claim.queries.length) : CHALLENGE_TEXT.noQueries}
|
||
</div>
|
||
<div className="space-y-1.5">
|
||
{claim.queries.map((q, i) => <QueryCard key={`${q.alias}-${i}`} id={`${baseId}-q-${q.alias}`} query={q} />)}
|
||
</div>
|
||
</section>
|
||
</>
|
||
)
|
||
}
|
||
|
||
function QueryCard({ id, query }: { id: string; query: ChallengeQuery }) {
|
||
return (
|
||
<div id={id} data-challenge-query={query.alias}
|
||
className="min-w-0 rounded data-[flash]:outline data-[flash]:outline-solid data-[flash]:outline-2 data-[flash]:outline-offset-2 data-[flash=focus]:outline-[color:var(--accent)]">
|
||
<div className="mb-1 flex min-w-0 items-center gap-2">
|
||
{/* 从理由里的数字跳过来时焦点落在这里:得看得见落在哪 */}
|
||
<span tabIndex={-1} data-challenge-query-head=""
|
||
className="min-w-0 flex-1 truncate rounded-sm text-2xs font-medium text-faint focus:outline-none focus-visible:outline focus-visible:outline-solid focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-[color:var(--accent)]">
|
||
{EVIDENCE_TEXT.query(query.alias)}
|
||
{query.source && <span className="mono ml-1.5 font-normal">{query.source}</span>}
|
||
</span>
|
||
{query.sql && <CopyChip label={EVIDENCE_TEXT.copySql} text={() => query.sql} />}
|
||
</div>
|
||
{query.sql && (
|
||
<pre className="mono mb-1 max-h-28 overflow-auto whitespace-pre-wrap rounded bg-panel px-1.5 py-1 text-2xs leading-relaxed text-dim [overflow-wrap:anywhere]"
|
||
data-challenge-sql="">
|
||
{query.sql}
|
||
</pre>
|
||
)}
|
||
<div className="tnum flex flex-wrap gap-x-2 text-2xs text-faint">
|
||
{query.row_count != null && <span data-challenge-rows={query.row_count}>{CHALLENGE_TEXT.rows(query.row_count)}</span>}
|
||
{query.truncated && (
|
||
<span data-challenge-truncated="" style={{ color: 'var(--st-waiting)' }}>{CHALLENGE_TEXT.truncated}</span>
|
||
)}
|
||
</div>
|
||
</div>
|
||
)
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 理由
|
||
|
||
/**
|
||
* 理由正文。有理由文档时按文档画:数字的出处照报告里的样子(有出处的实线、裸数字点状线加「无证据」),有出处的数字后面
|
||
* 挂查询编号,点一下跳到那次查询。文档可能直接放在工件里,也可能是另一个工件的 id(约定没定死,两种都认);
|
||
* 都没有、或者取不到时按渲染后的正文显示,数字照写,只是不标出处
|
||
*/
|
||
function Rationale({ claim, onJump }: { claim: ChallengeClaim; onJump: (alias: string) => void }) {
|
||
const ref = claim.rationale_doc
|
||
const inline = ref && typeof ref === 'object' ? asDoc(ref) : null
|
||
const artifact = typeof ref === 'string' ? ref : ''
|
||
const slot = useEvidence((s) => (artifact ? s.docs[artifact] : undefined))
|
||
const loadDoc = useEvidence((s) => s.loadDoc)
|
||
useEffect(() => { if (artifact) void loadDoc(artifact) }, [artifact, loadDoc])
|
||
const doc = inline ?? (slot?.status === 'ok' ? slot.data ?? null : null)
|
||
if (doc && (doc.blocks ?? []).length) return <RationaleDoc doc={doc} onJump={onJump} />
|
||
if (artifact && slot?.status !== 'error' && !doc) {
|
||
return <div className="text-2xs text-faint" data-challenge-doc-loading="">{CHALLENGE_TEXT.docLoading}</div>
|
||
}
|
||
if (!claim.rationale.trim()) return <div className="text-2xs text-faint">{CHALLENGE_TEXT.rationaleEmpty}</div>
|
||
return <div data-challenge-rationale-text=""><Markdown text={claim.rationale} dense /></div>
|
||
}
|
||
|
||
/** 列表项从哪一个片段开始:同 EvidenceDoc(行首的「- 」「1. 」是结构片段) */
|
||
const ITEM_START = /(^|\n)[ \t]*([-*+]|\d+[.)])[ \t]+$/
|
||
|
||
function RationaleDoc({ doc, onJump }: { doc: EvidenceDocData; onJump: (alias: string) => void }) {
|
||
return (
|
||
<div className="min-w-0 space-y-1.5 text-[11.5px] leading-relaxed" data-challenge-doc="">
|
||
{doc.blocks.map((block, b) => <RationaleBlock key={block.id ?? b} block={block} doc={doc} onJump={onJump} />)}
|
||
</div>
|
||
)
|
||
}
|
||
|
||
/** 一块:外观借 Markdown 的 BlockView,和报告文档、普通答案长得一样(块的分法同 EvidenceDoc 的 DocBlock) */
|
||
function RationaleBlock({ block, doc, onJump }: { block: EvidenceBlock; doc: EvidenceDocData; onJump: (alias: string) => void }) {
|
||
const units = block.units ?? []
|
||
const unit = (u: EvidenceUnit, code = false) => <RationaleUnit key={u.id} unit={u} doc={doc} code={code} onJump={onJump} />
|
||
switch (block.type) {
|
||
case 'heading':
|
||
return <BlockView dense shape={{ kind: 'h', level: block.level ?? 3, body: units.map((u) => unit(u)) }} />
|
||
case 'hr':
|
||
return <BlockView dense shape={{ kind: 'hr' }} />
|
||
case 'quote':
|
||
return <BlockView dense shape={{ kind: 'quote', body: units.map((u) => unit(u)) }} />
|
||
case 'code':
|
||
return <BlockView dense shape={{ kind: 'code', lang: block.lang ?? '', code: units.map(unitText).join(''), body: units.map((u) => unit(u, true)) }} />
|
||
case 'list': {
|
||
const items: { key: string; depth: number; units: EvidenceUnit[] }[] = []
|
||
for (const u of units) {
|
||
const lead = u.segments?.[0]
|
||
if (!items.length || (lead?.kind === 'structural' && ITEM_START.test(lead.text))) {
|
||
items.push({ key: u.id, depth: u.depth ?? 0, units: [u] })
|
||
} else items[items.length - 1].units.push(u)
|
||
}
|
||
return (
|
||
<BlockView dense shape={{
|
||
kind: 'list', ordered: !!block.ordered, start: block.start, fitMarkers: true,
|
||
items: items.map((it) => ({ key: it.key, depth: it.depth, body: it.units.map((u) => unit(u)) })),
|
||
}} />
|
||
)
|
||
}
|
||
case 'table': {
|
||
const cells = new Map<string, EvidenceUnit[]>()
|
||
let cols = 0
|
||
const rowIds: number[] = []
|
||
for (const u of units) {
|
||
const loc = u.loc ?? { row: 0, col: 0 }
|
||
cells.set(`${loc.row}:${loc.col}`, [...(cells.get(`${loc.row}:${loc.col}`) ?? []), u])
|
||
cols = Math.max(cols, loc.col + 1)
|
||
if (loc.row >= 0 && !rowIds.includes(loc.row)) rowIds.push(loc.row)
|
||
}
|
||
rowIds.sort((a, b) => a - b)
|
||
const plain = (r: number, c: number) => (cells.get(`${r}:${c}`) ?? []).map(unitText).join('')
|
||
const node = (r: number, c: number) => (cells.get(`${r}:${c}`) ?? []).map((u) => unit(u))
|
||
const head = Array.from({ length: cols }, (_, c) => plain(-1, c))
|
||
const body = rowIds.map((r) => Array.from({ length: cols }, (_, c) => plain(r, c)))
|
||
return (
|
||
<BlockView dense shape={{
|
||
kind: 'table',
|
||
head: Array.from({ length: cols }, (_, c) => node(-1, c)),
|
||
rows: rowIds.map((r) => Array.from({ length: cols }, (_, c) => node(r, c))),
|
||
numeric: numericColumns(head, body),
|
||
csv: () => [head, ...body].map((r) => r.join(',')).join('\n'),
|
||
}} />
|
||
)
|
||
}
|
||
default:
|
||
return <BlockView dense shape={{ kind: 'p', body: units.map((u) => unit(u)) }} />
|
||
}
|
||
}
|
||
|
||
/** 片段的颜色写成变量交给 index.css 的 .ev-seg / .ev-mark(同 EvidenceDoc) */
|
||
const evStyle = (state: EvidenceStateCode) => ({
|
||
'--ev-line': EVIDENCE_STATE[state].decoration, '--ev-soft': EVIDENCE_STATE[state].soft,
|
||
}) as CSSProperties
|
||
|
||
/** 引用的是查询结果里的一格:返回查询编号 */
|
||
function cellAlias(seg: EvidenceSegment, doc: EvidenceDocData): string | null {
|
||
const cite = seg.cite
|
||
if (!cite?.alias || segmentState(seg) !== 'deterministic') return null
|
||
const entry = doc.catalog?.[cite.alias]
|
||
return cite.kind === 'cell' || (cite.kind !== 'metric' && cite.kind !== 'input' && entry?.kind === 'query') ? cite.alias : null
|
||
}
|
||
|
||
/**
|
||
* 一句话:文字按行内 Markdown 渲染(整句算一次样式,同 EvidenceDoc 的 UnitView)。有出处的数字是按钮,后面挂查询编号;
|
||
* 裸数字、疑似不存在的名称画点状线,句末挂「无证据」「疑似不存在的名称」。别的片段(表名、字段名的链接)照普通文字
|
||
*/
|
||
function RationaleUnit({ unit, doc, code, onJump }: {
|
||
unit: EvidenceUnit; doc: EvidenceDocData; code: boolean; onJump: (alias: string) => void
|
||
}) {
|
||
const segs = (unit.segments ?? []).filter((s) => s.kind !== 'structural')
|
||
const whole = segs.map((s) => s.text).join('')
|
||
const styles = useMemo(() => (code ? null : inlineStyles(whole)), [whole, code])
|
||
const alerts = new Set<EvidenceStateCode>()
|
||
let pos = 0
|
||
const nodes = segs.map((s) => {
|
||
const from = pos
|
||
pos += s.text.length
|
||
const state = segmentState(s)
|
||
const alias = cellAlias(s, doc)
|
||
const body = styles ? <StyledSlice text={whole} styles={styles} from={from} to={pos} links={!state} /> : s.text
|
||
if (alias) {
|
||
const source = sourceOf(s, doc)
|
||
return (
|
||
<button key={s.id} type="button" className="ev-seg" data-ev-state="deterministic" data-ev-line="solid"
|
||
data-challenge-cite={alias} style={evStyle('deterministic')} title={source}
|
||
aria-label={CHALLENGE_TEXT.cited(s.text, source)} onClick={() => onJump(alias)}>
|
||
{body}
|
||
{/* inline-block:不吃上面那条下划线 */}
|
||
<sup className="mono ml-px inline-block select-none text-[9px] font-semibold text-faint" aria-hidden>{alias}</sup>
|
||
</button>
|
||
)
|
||
}
|
||
if (state === 'none' || state === 'suspect') {
|
||
alerts.add(state)
|
||
return (
|
||
<span key={s.id} className="ev-mark" data-ev-state={state} data-ev-line="dotted" style={evStyle(state)}
|
||
title={segmentLabel(s, doc)}>
|
||
{body}<span className="sr-only">({EVIDENCE_STATE_LABEL[state]})</span>
|
||
</span>
|
||
)
|
||
}
|
||
return <span key={s.id}>{s.strong ? <strong className="font-semibold">{body}</strong> : body}</span>
|
||
})
|
||
return (
|
||
<>
|
||
{nodes}
|
||
{!code && [...alerts].map((state) => (
|
||
<span key={state} className="ev-tag" aria-hidden="true" title={EVIDENCE_STATE[state].hint} data-ev-tag={state}>
|
||
{EVIDENCE_STATE[state].glyph}{EVIDENCE_STATE_LABEL[state]}
|
||
</span>
|
||
))}
|
||
</>
|
||
)
|
||
}
|