合入集成分支 feat/data-catalog(d897981,含 F2a 的证据面板、时间线和服务端修复):自动合并,没有冲突;catalog_profile._relation_finding 两边的改动(F2b 的 previous_status、F2a 的 cardinality_checked 写在关系上)互不重叠

This commit is contained in:
ThearchyHelios
2026-10-04 02:46:01 +08:00
45 changed files with 2007 additions and 278 deletions
+14 -2
View File
@@ -14,8 +14,8 @@ import mdSamples from '../run/__tests__/markdown-samples.json'
import evidenceFixture from '../run/__tests__/evidence-doc.json'
import evidenceJudge from '../run/__tests__/evidence-judge.json'
import {
CALIBER_ONE_OUTPUT, CALIBERS_OUTPUT, COPILOT_CATALOG_PATCH, COPILOT_CONTEXT, COPILOT_CONTEXT_FALLBACK, COPILOT_STUCK, COPILOT_TOOLS_DROPPED, MIXED_OUTPUT, abandonedRun, cancelledRun, exhaustedTeam, longLoop,
markupRun, mergeRun, mixedRun, pipelineRun, repairRun, teamRun, timeoutRun,
CALIBER_ONE_OUTPUT, CALIBERS_OUTPUT, SQL_DEGRADED_OUTPUT, COPILOT_CATALOG_PATCH, COPILOT_CONTEXT, COPILOT_CONTEXT_FALLBACK, COPILOT_STUCK, COPILOT_TOOLS_DROPPED, MIXED_OUTPUT, abandonedRun, cancelledRun, exhaustedTeam, longLoop,
markupRun, mergeRun, mixedRun, parallelQueryRun, pipelineRun, repairRun, teamRun, timeoutRun,
} from '../run/__tests__/synthetic'
import '../index.css'
@@ -302,6 +302,11 @@ function synthetic(name: string): StreamTurn[] {
steps: decodeRun(ev, { status: 'succeeded' }), output: MIXED_OUTPUT, runId: 'syn-issued',
runClass: 'exploratory', review: REVIEW_DEGRADED_TURN.review }]
}
case 'issued-sql':
// 数字都有出处,却因为查询没通过 SQL 检查而降档:横幅单列说明
return [{ id: name, question: '上周订单金额', phase: 'done', status: '已完成',
steps: decodeRun(parallelQueryRun(), { status: 'succeeded' }), runId: 'syn-issued-sql', runClass: 'formal',
output: SQL_DEGRADED_OUTPUT }]
case 'calibers':
case 'caliber-one': {
// 按口径卡清点回指的数字:两张卡各数各的;只有一张卡时直说都来自它
@@ -364,6 +369,10 @@ function synthetic(name: string): StreamTurn[] {
columns: ['factory_code', 'line_name', 'attribute_group', 'output_qty'],
rows: [['1063', '一号线', '001', 1520], ['1064', '二号线', '002', 1310], ['1065', '三号线', '001', 980]],
row_count: 3 }) } }]
case 'parallel':
// 两个并行的查询节点用同一个工具;第一条查询没通过 SQL 检查,口径卡的问题指到它的 SQL
return [{ id: 'parallel', question: '订单金额和退款数', phase: 'done', status: '已完成',
steps: decodeRun(parallelQueryRun(), { status: 'succeeded' }) }]
case 'merge':
// 合并查询:两个库各查一次、在库外按门店合并,带两道警告(键类型不一致、行数放大)
return [{ id: 'merge', question: '按门店合并销售和到店人数', phase: 'done', status: '已完成',
@@ -533,6 +542,9 @@ function Preview() {
turns={synthetic(syn)}
onStepHover={params.get('link') === '1' ? (id) => { (window as any).__hovered = id } : undefined}
onStepFocus={params.get('link') === '1' ? (id) => { linked.push(id) } : undefined}
// 「打开设置」:记下要打开哪个节点、落到哪一栏(指标的问题落到来源查询的 SQL)
onStepOpen={params.get('link') === '1'
? (id, field) => { ((window as any).__opened ??= []).push([id, field ?? null]) } : undefined}
renderTurnActions={(t) => (t.phase === 'error'
? <button type="button" className="btn btn-xs"><RotateCw size={11} aria-hidden /> 重试本轮</button>
: null)}
+6
View File
@@ -57,6 +57,12 @@ export function sqlCheckOf(v: unknown): SqlCheckItem | null {
}
}
/** 一组检查(事件、接口里的 checks 字段,助手自查的问题):认不出的丢掉 */
export function sqlChecksOf(v: unknown): SqlCheckItem[] {
const list: unknown[] = Array.isArray(v) ? v : []
return list.map(sqlCheckOf).filter((c): c is SqlCheckItem => c !== null)
}
/** 一条检查写成一行(时间线的展开区、交给助手再修的清单):「错误 · 一对多关联后重复计算:……(涉及 orders.amount)」 */
export function sqlCheckLine(c: SqlCheckItem): string {
const where = sqlCheckWhere(c)
+52 -4
View File
@@ -2051,7 +2051,10 @@ export const CATALOG_TEXT = {
draftFailed: '起草中断',
draftSummary: (added: number, updated: number, removed: number) =>
`新增 ${formatNumber(added)} 项、更新 ${formatNumber(updated)} 项${removed ? `、删除 ${formatNumber(removed)} 项` : ''}`,
draftNoChange: '没有变化:起草结果与现有目录一致',
// 只在起草确实给出了内容、只是和现有目录一致时用:有表的模型起草失败或没给出可用内容(model_error)时
// 不能说「没有变化」,改用 draftNothingWritten
draftNoChange: '没有变化:起草出的内容与现有目录一致',
draftNothingWritten: '目录没有更新:模型没有给出可用的内容,原因见下方',
draftModelSkipped: (reason: string) => `模型未参与起草:${reason.replace(/[。.]$/, '')}。已按注释、外键和命名起草。`,
draftModelUsed: (model: string) => `模型:${model}`,
draftTableErrors: (n: number) => `${formatNumber(n)} 张表未能起草`,
@@ -2545,7 +2548,8 @@ export const CATALOG_UI_TEXT = {
//
// 术语:
// - 「SQL 检查」:对照数据目录找出能执行、数却可能不对的写法。七条规则,界面上写中文规则名,不露规则编号。
// - 级别:错误(依据已确认,结果必然有误)、提醒(依据已确认,结果很可能有误)、提示(依据只是推断,仅供参考)。
// - 级别:错误(依据已核实,结果很可能有误)、提醒(依据已确认,结果可能有误)、提示(依据只是推断,仅供参考)。
// 一对多关联后重复计算:只有一对多人工确认过、或数据剖析用数据核实过时才是错误;只凭外键推出的是提醒。
// 颜色走语义令牌:错误 --st-failed,提醒 --st-waiting,提示 --accent。
// ===========================================================================
@@ -2576,8 +2580,8 @@ export const SQL_CHECK_LEVEL_LABEL: Record<SqlCheckLevel, string> = {
}
export const SQL_CHECK_LEVEL_HINT: Record<SqlCheckLevel, string> = {
error: '依据已确认,结果必然有误',
warning: '依据已确认,结果很可能有误',
error: '依据已核实,结果很可能有误,需要修改',
warning: '依据已确认,结果可能有误,请核对',
info: '依据尚未确认(推断),仅供参考',
}
@@ -2604,3 +2608,47 @@ export const SQL_CHECK_TEXT = {
assistantNextChat: '可在画布中打开此工作流,修改对应节点「参数」中的 SQL;检查依据有误时,请在数据目录中修正对应项',
assistantInfoNext: '这些检查的依据尚未确认,仅供参考。在数据目录中确认相关项后,检查结论更可靠',
}
// ===========================================================================
// 证据面板、运行时间线里的 SQL 检查和数据目录版本,助手「参考了哪些表」(数据目录完整性修复 F2a)
//
// - 证据面板的查询步骤写这次查询对照的是哪一版数据目录(表结构快照里冻结的那份):「数据目录:入园记录 第 3 版」。
// - 合并查询的每个输入带着它自己的 SQL 检查结果。
// - 运行时间线:同一条查询的问题只列一行,写明受影响的指标;「打开设置」落到来源查询节点的 SQL 上。
// - 助手「参考了哪些表」:带字段的表和只提供了表名的表分开数。
// ===========================================================================
export const RUN_SQL_CHECK_TEXT = {
/** 证据面板查询步骤:SQL 检查对照的数据目录版本 */
catalogLine: (items: { name: string; version?: number | null }[]) =>
`数据目录:${items.map((i) => (i.version != null ? `${i.name} 第 ${formatNumber(i.version)} 版` : i.name)).join('、')}`,
catalogHint: '这次查询时冻结的数据目录版本,SQL 检查对照的就是这一版',
/** 合并查询的输入:这个输入查询自己的 SQL 检查 */
mergeInputChecks: (alias: string) => `输入 ${alias} 的 SQL 检查`,
/** 运行时间线:一条查询的问题影响了几个指标 */
metricsTitle: (names: string[], n = 1) => {
const who = names.length > 3
? `指标${names.slice(0, 3).map((x) => `「${x}」`).join('')}等 ${formatNumber(names.length)} 个`
: `指标${names.map((x) => `「${x}」`).join('')}`
return n > 1 ? `${who}所依据的查询有 ${formatNumber(n)} 处未通过 SQL 检查` : `${who}所依据的查询未通过 SQL 检查`
},
/** 运行时间线:一次查询的 SQL 检查结果(查询那一行展开后) */
toolChecks: 'SQL 检查',
/** 「打开设置」落到来源查询节点的 SQL 上 */
openSql: (label?: string) => (label ? `打开「${label}」的 SQL` : '打开来源查询的 SQL'),
metricNext: '指标照常计算,但结果不可靠,出具按缺口降档。请修改来源查询的 SQL 后重新运行;检查依据有误时,请在数据目录中修正对应项',
/** 出具横幅、报告页:SQL 检查导致的降档单列一块 */
issuanceTitle: (tier: string) => (tier === 'degraded' ? '降档原因:所依据的查询未通过 SQL 检查' : '所依据的查询未通过 SQL 检查'),
issuanceQuery: '所依据的查询',
issuanceAffected: (refs: string) => `受影响:${refs}`,
issuanceNext: '数字的出处都对得上,但算出这些数的查询本身有问题,结果不可靠。请修改来源查询的 SQL 后重新运行;检查依据有误时,请在数据目录中修正对应项',
/** 其余缺口的标题(SQL 检查的那几条单列之后) */
otherGaps: '校验未全部完成:',
}
export const COPILOT_CONTEXT_TEXT = {
/** 标题:另有只提供了表名的表时,写明这个数只算带着字段的表 */
withFields: (n: number) => `参考了 ${formatNumber(n)} 张表的字段`,
namesOnly: (n: number) => `另有 ${formatNumber(n)} 张表只提供了表名`,
notPicked: '未能按需求挑选',
}
+9
View File
@@ -13,6 +13,7 @@ import {
} from '../../lib/evidence'
import { formatNumber } from '../../lib/format'
import { EVIDENCE_AUDIT_TEXT as T, UPGRADE_TEXT } from '../../lib/terms'
import { IssuanceBanner } from '../../run/AssistantStream'
import { EvidenceDoc, type EvidenceDocHandle } from '../../run/EvidenceDoc'
import { EvidenceGuessView } from '../../run/EvidenceGuess'
import { Markdown, inlineStyles } from '../../run/Markdown'
@@ -142,6 +143,13 @@ export function EvidencePane({ run, output, labelOf, refreshKey }: {
<SummaryBar mode={mode} seal={seal} message={audit.data?.seal?.message}
reports={graph.reports ?? []} labelOf={labelOf} />
<UpgradeBanner run={run} mode={mode} />
{/* 出具档位和降档原因写在报告上方:降档时只在侧栏小标签里写「SQL 检查未通过」,报告上却是绿色的
「10 个数字都有出处」,读的人会以为一切正常。SQL 检查导致的降档在横幅里单列一块 */}
{!!output?._issuance?.tier && (
<div data-evidence-issuance="">
<IssuanceBanner issuance={output._issuance} runClass={run.run_class} />
</div>
)}
{mode === 'cited' && reports.map((r) => {
const doc = docOf(r.node_id)
@@ -157,6 +165,7 @@ export function EvidencePane({ run, output, labelOf, refreshKey }: {
{doc ? (
<EvidenceDoc ref={(h) => { handles.current.set(r.node_id!, h) }} doc={doc} artifact={r.doc_artifact}
runId={run.id} runClass={run.run_class} label={r.fields?.join('、') || r.node_id} tally
tier={typeof output?._issuance?.tier === 'string' ? output._issuance.tier : undefined}
panel={wide ? 'dock' : 'auto'} dock={dock} onView={(o) => onView(r.node_id!, o)} />
) : slot?.status === 'error' ? (
<p className="text-2xs" style={{ color: 'var(--st-failed)' }}>{T.docGone(labelOf(r.node_id) ?? r.node_id ?? '')}</p>
+6 -2
View File
@@ -791,8 +791,12 @@ function RunView({ onBack, reveal, onRevealed }: {
clockSkewMs={trace.skewMs ?? 0}
onStepHover={setHoveredNode}
onStepFocus={focusNode}
// 没绑工具、轮数不够这种要去画布上改的:直接打开那个节点的设置,镜头也带过去
onStepOpen={(id) => { select(id); focusNode(id) }}
// 没绑工具、轮数不够这种要去画布上改的:直接打开那个节点的设置,镜头也带过去。
// 给了栏位(指标的问题出在来源查询的 SQL 上,field 是 args.sql)就落到那一栏
onStepOpen={(id, field) => {
if (field) revealField(id, field, { focus: true })
else { select(id); focusNode(id) }
}}
activeNodeId={hoveredNodeId}
reveal={stepReveal}
onRevealed={onRevealed}
+65 -16
View File
@@ -15,7 +15,8 @@ import { humanizeError } from '../lib/errors'
import { explainRunError } from '../lib/explain'
import { formatClock, formatDuration, formatNumber, NONE, shortId } from '../lib/format'
import { statusLabel } from '../lib/status'
import { EVIDENCE_TEXT, JUDGE_TEXT, MERGE_TEXT, evidenceTally, issuanceLabel, nodeTypeLabel } from '../lib/terms'
import { EVIDENCE_TEXT, JUDGE_TEXT, MERGE_TEXT, RUN_SQL_CHECK_TEXT, evidenceTally, issuanceLabel, nodeTypeLabel } from '../lib/terms'
import { SqlCheckList } from './SqlChecks'
import {
ISSUANCE_HINT, childrenByExec, compactSteps, parseQueryResult, progressOf, spread, teamVerdictOf,
type Exec, type FixKind, type ResultTable as Table, type Step, type StepKind, type TeamMemberEx,
@@ -24,7 +25,7 @@ import {
import { CODE_COLUMN, CopyChip, LEADING_ZERO, Markdown, type MarkSpec } from './Markdown'
import { ClaimTally, EvidenceField, type EvidenceDocHandle } from './EvidenceDoc'
import { EVIDENCE_STATE, claimProblems, docTally, evidenceFields, issuanceMarks, type EvidenceTally } from '../lib/evidence'
import type { EvidenceDocData } from '../types'
import type { EvidenceDocData, IssuanceSqlCheck } from '../types'
import { useRunClock } from './useRunClock'
import { CatalogPatchCard } from './CatalogPatchCard'
import type { CatalogPatch } from './catalogPatch'
@@ -135,8 +136,8 @@ interface StreamCtx {
dense: boolean
onHover?: (nodeId: string | null) => void
onFocus?: (nodeId: string) => void
/** 打开这个节点的设置去改(编排页)。下一步是「去画布改」的行据此给直达入口 */
onOpen?: (nodeId: string) => void
/** 打开这个节点的设置去改(编排页)。下一步是「去画布改」的行据此给直达入口;给了 field 就落到那一栏(args.sql) */
onOpen?: (nodeId: string, field?: string) => void
activeNodeId?: string | null
skewMs: number
openArtifact: (id: string, title?: string) => void
@@ -196,7 +197,7 @@ export function AssistantStream({
* 编排页:打开某个节点的设置。节点没绑工具、团队轮数不够这类要去画布上改的,
* 报错和提醒行据此给「打开设置」;不传就只说该去哪儿改
*/
onStepOpen?: (nodeId: string) => void
onStepOpen?: (nodeId: string, field?: string) => void
/** 画布上悬停的节点:对应的步骤行高亮 */
activeNodeId?: string | null
/** 贴着底部时,新步骤到来自动滚到底。离开底部就不再拽人 */
@@ -877,19 +878,23 @@ function failureOf(turn: StreamTurn): Failure | null {
* 下一步的直达入口。要去画布上改的,编排页能直接打开那个节点的设置;别处只说该去哪儿,
* 不装作能点。「接着跑」「重新运行」由页面自己放(renderTurnActions),这里不给
*/
function FixAction({ fix, nodeId, label, to, first }: {
function FixAction({ fix, nodeId, label, to, first, field }: {
fix?: FixKind | 'rerun'; nodeId?: string; label?: string
/** lib/explain 的 fixTo:直达要改的那一项 */
to?: string
/** lib/explain 的 fixFirst:先改好才接得下去,入口写明要改什么 */
first?: boolean
/** 要改的那一栏(args.sql:调用工具节点里写死的 SQL)。给了就落到那一栏,入口写「打开「取数」的 SQL」 */
field?: string
}) {
const { onOpen } = useContext(Ctx)
const cls = 'inline-flex shrink-0 items-center gap-1 rounded px-1 text-2xs text-[var(--accent)] underline-offset-2 transition-colors hover:bg-hover hover:underline'
if (fix === 'canvas' && nodeId && onOpen) {
const sql = field === 'args.sql' || field === 'sql'
return (
<button type="button" className={cls} data-fix="canvas" onClick={() => onOpen(nodeId)}>
<Settings2 size={10} aria-hidden /> 打开{label ? `「${label}」的` : ''}设置
<button type="button" className={cls} data-fix="canvas" data-fix-node={nodeId} data-fix-field={field || undefined}
onClick={() => onOpen(nodeId, field || undefined)}>
<Settings2 size={10} aria-hidden /> {sql ? RUN_SQL_CHECK_TEXT.openSql(label) : `打开${label ? `「${label}」的` : ''}设置`}
</button>
)
}
@@ -1064,7 +1069,7 @@ function StepLine({ step, depth, turnMs }: { step: Step; depth: number; turnMs?:
const [open, setOpen] = useState(false)
const Icon = ICONS[step.kind] ?? CircleDot
const result = step.result
const expandable = !!(step.detail || result || step.raw || step.artifact)
const expandable = !!(step.detail || result || step.raw || step.artifact || step.checks?.length)
const table = result ? parseQueryResult(result) : null
const status = step.status ?? 'done'
// 失败的节点:收着的时候就说为什么(和轮次顶上的报错同一份 lib/explain),展开再看原因、
@@ -1163,7 +1168,9 @@ function StepLine({ step, depth, turnMs }: { step: Step; depth: number; turnMs?:
<CornerDownRight size={10} className="mt-[2px] shrink-0" aria-hidden />
<span className="min-w-0 [overflow-wrap:anywhere]">{step.next}</span>
</span>
<FixAction fix={step.fix} nodeId={step.nodeId} />
{/* 要改的是另一个节点(指标的问题出在来源查询的 SQL 上):入口落到那个节点的那一栏 */}
<FixAction fix={step.fix} nodeId={step.fixNode ?? step.nodeId} field={step.fixField}
label={step.fixNode ? step.fixLabel : undefined} />
</div>
)}
@@ -1518,6 +1525,13 @@ function StepDetail({ step, table, explained }: {
</pre>
</div>
)}
{!!step.checks?.length && (
// 对照数据目录的 SQL 检查:查询那一行是这次查询的检查结果,指标那一行是来源查询没通过的那几条
<div className="text-2xs" data-step-sql-checks="">
<div className="mb-0.5 text-dim">{RUN_SQL_CHECK_TEXT.toolChecks}</div>
<SqlCheckList checks={step.checks} />
</div>
)}
{table
? <ResultTable table={table} artifact={step.artifact} title={step.title} />
: result && result !== step.detail && (
@@ -1854,8 +1868,9 @@ export function ResultTable({ table, artifact, title, full = false, highlight, m
<div className="flex flex-wrap items-center gap-x-2 gap-y-0.5 border-t px-1.5 py-1 text-2xs leading-relaxed text-dim">
<span className="tnum">
{[
rows.length < table.rows.length
? `显示前 ${formatNumber(rows.length)} / ${formatNumber(table.rows.length)} 行`
// total:结果一共几行(预览只存了前几行时比 rows 多,比如合并查询 6 行只预览 5 行)
rows.length < Math.max(table.total ?? 0, table.rows.length)
? `显示前 ${formatNumber(rows.length)} / ${formatNumber(Math.max(table.total ?? 0, table.rows.length))} 行`
: `${formatNumber(table.rows.length)} 行`,
hiddenCols > 0 ? `显示前 ${cols.length} / ${table.columns.length} 列` : null,
].filter(Boolean).join(' · ')}
@@ -2247,6 +2262,32 @@ function OutputValue({ value, marks, label }: { value: unknown; marks?: MarkSpec
)
}
/**
* 出具声明里没通过 SQL 检查的查询(sql_checks):每条写是哪次查询、什么问题、影响了哪些引用,下一步写改来源查询的 SQL。
* 出具横幅和报告页顶部共用。颜色跟着档位:降档用提醒色,不予出具用失败色
*/
export function IssuanceSqlChecks({ tier, checks }: { tier: string; checks: IssuanceSqlCheck[] }) {
const tone = tier === 'withheld' ? 'var(--st-failed)' : 'var(--st-waiting)'
return (
<div className="mt-1.5 rounded border px-2 py-1.5 text-2xs leading-relaxed" data-issuance-sql-checks={checks.length}
style={{ borderColor: `color-mix(in srgb, ${tone} 45%, var(--border))`, background: `color-mix(in srgb, ${tone} 6%, transparent)` }}>
<div className="flex items-center gap-1 font-medium" style={{ color: tone }}>
<AlertTriangle size={11} aria-hidden /> {RUN_SQL_CHECK_TEXT.issuanceTitle(tier)}
</div>
<ul className="mt-0.5 space-y-0.5">
{checks.map((c, i) => (
<li key={`${c.query ?? ''}:${i}`} className="[overflow-wrap:anywhere]" data-issuance-sql-check={c.node_id ?? ''}>
<span className="font-medium text-fg">{c.query || RUN_SQL_CHECK_TEXT.issuanceQuery}</span>
{!!c.problems?.length && <span className="text-fg">:{c.problems.join(';')}</span>}
{!!c.refs?.length && <span className="text-dim">({RUN_SQL_CHECK_TEXT.issuanceAffected(c.refs.join('、'))})</span>}
</li>
))}
</ul>
<div className="mt-0.5 text-dim">{RUN_SQL_CHECK_TEXT.issuanceNext}</div>
</div>
)
}
const TIER_META: Record<string, { color: string; soft: string; hint: string }> = {
formal: { color: 'var(--st-done)', soft: 'var(--st-done-soft)', hint: ISSUANCE_HINT.formal },
degraded: { color: 'var(--st-waiting)', soft: 'var(--st-waiting-soft)', hint: ISSUANCE_HINT.degraded },
@@ -2277,7 +2318,12 @@ export function IssuanceBanner({ issuance, runClass, evidence }: {
if (!tier) return null
const meta = TIER_META[tier] ?? { color: 'var(--st-waiting)', soft: 'var(--st-waiting-soft)', hint: '' }
const unmatched: any[] = issuance?.unmatched_numbers ?? []
const gaps: string[] = Array.isArray(issuance?.gaps) ? issuance.gaps.map(String) : []
// 没通过 SQL 检查的查询(出具声明的 sql_checks)单列一块、写在显眼处:数字都有出处,降档却是因为算数的查询本身有问题。
// 单列了的那几句(gap)不在其余缺口里重复
const sqlChecks: IssuanceSqlCheck[] = (Array.isArray(issuance?.sql_checks) ? issuance.sql_checks : [])
.filter((x: unknown): x is IssuanceSqlCheck => !!x && typeof x === 'object')
const sqlGaps = new Set(sqlChecks.map((x) => x.gap).filter(Boolean))
const gaps: string[] = (Array.isArray(issuance?.gaps) ? issuance.gaps.map(String) : []).filter((g: string) => !sqlGaps.has(g))
const calibers: any[] = issuance?.calibers ?? []
const matched = Number(issuance?.matched_numbers ?? 0)
// 逐个数字的出处(matched[].caliber 形如「口径名 @ v2」):有它就能按卡数清楚,
@@ -2294,6 +2340,8 @@ export function IssuanceBanner({ issuance, runClass, evidence }: {
const uncitedClaims = Number(issuance?.claims?.uncited_claims ?? 0) || 0
const numbers = counts ? evidenceTally(counts.cited, counts.total, counts.other) : ''
const numbersOk = !counts?.none && !counts?.other
// 数字都有出处只在完整出具时用绿色:降档时「10 个数字都有出处」画成绿的,读的人会以为一切正常
const numbersColor = !numbersOk ? 'var(--st-waiting)' : tier === 'formal' ? 'var(--st-done)' : 'var(--text-dim)'
// 四期:结论句有判定(开了裁判,或探索运行里按需判过)时多一段「结论 4 句(支持 3 · 无证据 1)」。
// 没开裁判的文档里没挂依据的都数在这一段的「无证据」里,不再另起一句;开了裁判的文档里,没挂依据却送了
// 裁判的句子按判定数、预筛放掉的不数——出具照样按没挂依据计缺口(require_citation、judge 都是),这时
@@ -2325,7 +2373,7 @@ export function IssuanceBanner({ issuance, runClass, evidence }: {
// 结论句靠句末徽标定位;只是没挂依据的结论句没有徽标,定位不到
<div className="mt-1 flex flex-wrap items-center gap-2 text-2xs" data-evidence-line="">
{numbers && (
<span className="tnum" style={{ color: numbersOk ? 'var(--st-done)' : 'var(--st-waiting)' }}>{numbers}</span>
<span className="tnum" style={{ color: numbersColor }} data-evidence-line-numbers="">{numbers}</span>
)}
{suspect > 0 && (
<span className="tnum" style={{ color: 'var(--st-waiting)' }} data-evidence-line-suspect="">
@@ -2347,9 +2395,10 @@ export function IssuanceBanner({ issuance, runClass, evidence }: {
</div>
)}
{!!sqlChecks.length && <IssuanceSqlChecks tier={tier} checks={sqlChecks} />}
{!!gaps.length && (
<div className="mt-1.5 text-2xs leading-relaxed" style={{ color: 'var(--st-waiting)' }}>
<div className="font-medium">校验未全部完成:</div>
<div className="mt-1.5 text-2xs leading-relaxed" style={{ color: 'var(--st-waiting)' }} data-issuance-gaps="">
<div className="font-medium">{RUN_SQL_CHECK_TEXT.otherGaps}</div>
<ul className="mt-0.5 space-y-0.5 pl-2">
{gaps.map((g) => <li key={g}>· {g}</li>)}
</ul>
+13 -4
View File
@@ -212,7 +212,13 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
* (on_demand / inline),没开的看这里,不给就按运行 id 取一次
*/
runClass?: string
}>(function EvidenceDoc({ doc, artifact, runId, dense = false, label, panel = 'auto', dock, onView, tally = false, runClass }, ref) {
/**
* 这次出具的档位(output._issuance.tier)。不是完整出具时,「N 个数字都有出处」不画成绿色:
* 数字的出处都对得上,档位却因为别的原因(比如查询没通过 SQL 检查)降了
*/
tier?: string
}>(function EvidenceDoc({ doc, artifact, runId, dense = false, label, panel = 'auto', dock, onView, tally = false, runClass,
tier }, ref) {
const blocks = useMemo(() => doc.blocks ?? [], [doc])
const report = doc.node_id || undefined
// 封存之后按需追加的判定:盖过文档里的「未裁判 · 按需」。只换句末徽标,封存的文档一个字不改
@@ -447,7 +453,7 @@ export const EvidenceDoc = forwardRef<EvidenceDocHandle, {
<p id={summaryId} className="sr-only" data-evidence-summary="">{summary}</p>
<div className="sr-only" aria-live="polite" aria-atomic="true">{announce}</div>
{tally && (counts.total > 0 || counts.other > 0 || !!counts.suspect || !!claims?.total) && (
<EvidenceTally counts={{ ...counts, claims }} onNext={() => {
<EvidenceTally counts={{ ...counts, claims }} tier={tier} onNext={() => {
const target = step(model.alerts, current, 1)
if (target) { focusSeg(target, { flash: true }); openSeg(target) } else openViolations()
}} onList={doc.violations?.length ? openViolations : undefined} />
@@ -520,10 +526,12 @@ function usePanelMode(panel: 'auto' | PanelMode, dense: boolean): PanelMode {
* 证据条:没有出具横幅时由文档自己说「7/12 数字有出处 · 无证据 5 · 另有 1 处引用解析不了」,
* 有结论句判定时接着说「结论 4 句(支持 3 · 不支持 1)」
*/
export function EvidenceTally({ counts, onNext, onList }: {
export function EvidenceTally({ counts, onNext, onList, tier }: {
counts: Pick<Tally, 'total' | 'cited' | 'none' | 'other' | 'suspect' | 'claims'>
onNext?: () => void
onList?: () => void
/** 出具档位:给了、又不是完整出具时,数字都有出处也不用绿色 */
tier?: string
}) {
const suspect = counts.suspect ?? 0
const claims = counts.claims
@@ -532,7 +540,8 @@ export function EvidenceTally({ counts, onNext, onList }: {
return (
<div className="mb-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-2xs" data-evidence-tally="">
{numbers && (
<span className="tnum" style={{ color: !counts.none && !counts.other ? 'var(--st-done)' : 'var(--st-waiting)' }}>
<span className="tnum" data-evidence-tally-numbers=""
style={{ color: counts.none || counts.other ? 'var(--st-waiting)' : !tier || tier === 'formal' ? 'var(--st-done)' : 'var(--text-dim)' }}>
{numbers}
</span>
)}
+15 -1
View File
@@ -18,7 +18,7 @@ import {
} from '../lib/evidence'
import { humanizeError } from '../lib/errors'
import { formatDateTime, formatNumber, NONE, shortId } from '../lib/format'
import { EVIDENCE_TEXT, JUDGE_TEXT, MERGE_TEXT, NODE_TYPE_LABEL, SQL_CHECK_TEXT, nodeTypeLabel } from '../lib/terms'
import { EVIDENCE_TEXT, JUDGE_TEXT, MERGE_TEXT, NODE_TYPE_LABEL, RUN_SQL_CHECK_TEXT, SQL_CHECK_TEXT, nodeTypeLabel } from '../lib/terms'
import { useCatalog } from '../store/catalog'
import { askKey, segmentKey, useEvidence, useExplore, useVerdicts } from '../store/evidence'
import type {
@@ -1371,6 +1371,13 @@ function QueryPart({ id, step, seal, masked }: { id: string; step: EvidenceStep;
<CopyChip label={step.merge ? MERGE_TEXT.copySql : EVIDENCE_TEXT.copySql} text={() => step.sql ?? ''} />
)}
</div>
{!!step.catalog?.length && (
// SQL 检查对照的是哪一版数据目录(查询当时冻结进表结构快照的那份):事后目录改了、升了版本,看得出这次按的是哪一版
<div className="mb-1 text-2xs text-faint [overflow-wrap:anywhere]" data-ev-catalog=""
title={RUN_SQL_CHECK_TEXT.catalogHint}>
{RUN_SQL_CHECK_TEXT.catalogLine(step.catalog.map((c) => ({ name: c.label || c.table, version: c.version })))}
</div>
)}
{step.merge && <MergeInputs merge={step.merge} />}
{step.sql && step.merge && <div className="mb-0.5 text-2xs text-faint">{MERGE_TEXT.sql}</div>}
{step.sql && (
@@ -1471,6 +1478,13 @@ function MergeInputs({ merge }: { merge: EvidenceMerge }) {
.filter(Boolean).join(' · ')}
</span>
{host.onNode && i.node_id && <NodeChip id={i.node_id} />}
{!!i.checks?.length && (
// 输入查询自己的 SQL 检查:被引用的格追不到逐格来历时,下面没有这个输入的查询步骤,问题只能在这里看到
<div className="mt-0.5 w-full" data-ev-merge-input-checks={i.alias}>
<div className="mb-0.5 text-faint">{RUN_SQL_CHECK_TEXT.mergeInputChecks(i.alias)}</div>
<SqlCheckList checks={i.checks} />
</div>
)}
</li>
))}
</ul>
+63 -2
View File
@@ -188,6 +188,29 @@ export const CALIBERS_OUTPUT = {
},
}
/**
* 数字都有出处,却因为算数的查询没通过 SQL 检查而降档(engine/nodes/io.py 的 sql_checks):横幅单列一块说明,
* 那一句不在其余缺口里重复;「都有出处」不画成绿色
*/
export const SQL_GAP = `查询「订单金额查询」(Q1)未通过 SQL 检查(${'「订单」关联「订单明细」是一对多,对「订单」的「订单金额」求和会重复计算'}),结果不可靠;受影响的引用:指标「订单金额」、Q1 第 1 行「gmv」`
export const SQL_DEGRADED_OUTPUT = {
answer: '上周订单金额 **119,160** 元。',
_issuance: {
tier: 'degraded',
calibers: [{ node: 'k1', caliber: '订单口径', version: 'v2' }],
metrics_checked: 1,
missing_required: [],
missing_expected: [],
unmatched_numbers: [],
matched_numbers: 1,
matched: [{ token: '119,160', metric: 'gmv', caliber: '订单口径 @ v2' }],
gaps: [SQL_GAP, '协作团队「分析团队」用完 2 轮仍未完成,交付的是成员最后的回复'],
sql_checks: [{ query: '查询「订单金额查询」(Q1)', node_id: 'q_a',
problems: ['「订单」关联「订单明细」是一对多,对「订单」的「订单金额」求和会重复计算'],
refs: ['指标「订单金额」', 'Q1 第 1 行「gmv」'], gap: SQL_GAP }],
},
}
/** 只有一张口径卡、逐个出处都指向它:直说「都来自这张卡」 */
export const CALIBER_ONE_OUTPUT = {
answer: '上周订单 **128** 单,已付款 **96** 单。',
@@ -365,15 +388,53 @@ export function mergeRun(): RunEvent[] {
truncated: false, duration_ms: 12, query_artifact: 'mq-merge', lineage: true,
warnings: [{ code: 'key_type_mismatch', message: '键类型' }, { code: 'rows_grew', message: '行数' }],
}, 0.02)
ev('log', 'merge', { level: 'warn', code: 'merge_key_type',
// 结构化字段和 engine/merge_query._warnings 一致:界面读字段,不从 message 里解析
ev('log', 'merge', { level: 'warn', code: 'merge_key_type', keys: ['s.门店', 'v.门店'],
detail: "s.门店 是文本(例如 '01'),v.门店 是数值(例如 1)",
message: "合并键类型不一致:s.门店 是文本(例如 '01'),v.门店 是数值(例如 1)。SQLite 比较时会做隐式转换:文本形式的编号(如 '001'、'01')都会等于数值 1,也可能完全匹配不上。请在源查询中统一类型,或在合并 SQL 中用 CAST 明确转换" })
ev('log', 'merge', { level: 'warn', code: 'merge_rows_grew',
ev('log', 'merge', { level: 'warn', code: 'merge_rows_grew', rows: 8, input: 's', input_rows: 4,
duplicates: '「s」中按(门店)有重复的键,例如 01 出现 2 次等 2 组;「v」中按(门店)有重复的键,例如 1 出现 2 次等 2 组',
message: '合并结果有 8 行,多于行数最多的输入「s」(4 行):合并键可能不唯一,同一行被重复匹配。「s」中按(门店)有重复的键,例如 01 出现 2 次等 2 组;「v」中按(门店)有重复的键,例如 1 出现 2 次等 2 组。请检查合并条件是否覆盖了全部键(例如同时按日期和门店),或先在源库里聚合到相同粒度' })
ev('node.finished', 'merge', { duration_ms: 15, attempt: 1 })
ev('run.finished', null, { output: {}, timing: { wall_ms: 400, active_ms: 400, wait_ms: 0 } })
return out
}
/**
* 两个查询节点并行、用同一个数据源工具(独立的调用工具节点不带 call_id):时间线要按节点配对,不能按工具名。
* 第一条查询一对多关联后求和,tool.end 带着 SQL 检查结果;口径卡里两个指标取自它,日志按查询归并成一行,
* 带着来源查询节点和它的 SQL 那一栏(engine/nodes/metrics._emit_sql_check_logs)
*/
export const PARALLEL_SQL_A = 'SELECT SUM(o.total_amount) AS gmv FROM orders o JOIN order_items i ON i.order_id = o.id'
export const PARALLEL_SQL_B = 'SELECT COUNT(*) AS refunds FROM refunds'
export const FANOUT_PROBLEM = '「订单」关联「订单明细」是一对多,对「订单」的「订单金额」求和会重复计算'
export const FANOUT_CHECK = { code: 'fanout_sum', level: 'error', table: 'orders', column: 'total_amount',
relation_id: 'r1a2b3c4d5e6', message: `${FANOUT_PROBLEM}。请先按订单汇总明细再关联` }
export function parallelQueryRun(): RunEvent[] {
const { out, ev } = builder('syn-parallel')
ev('run.started', null, { nodes: 4, resumed: false })
ev('node.started', 'q_a', { node_type: 'tool', label: '订单金额查询' })
ev('node.started', 'q_b', { node_type: 'tool', label: '退款查询' })
ev('tool.start', 'q_a', { tool: 'db_query__shop', args: { sql: PARALLEL_SQL_A } })
ev('tool.start', 'q_b', { tool: 'db_query__shop', args: { sql: PARALLEL_SQL_B } })
// 先开始的那条先结束:按工具名配对时,它会配到后开始的那一行上
ev('tool.end', 'q_a', { tool: 'db_query__shop', duration_ms: 40, artifact: 'ts-q_a', query_artifact: 'qs-q_a',
preview: JSON.stringify({ columns: ['gmv'], rows: [[119160]], row_count: 1, truncated: false, sql: PARALLEL_SQL_A, source: 'shop' }),
checks: [FANOUT_CHECK] }, 0.04)
ev('tool.end', 'q_b', { tool: 'db_query__shop', duration_ms: 30, artifact: 'ts-q_b', query_artifact: 'qs-q_b',
preview: JSON.stringify({ columns: ['refunds'], rows: [[7]], row_count: 1, truncated: false, sql: PARALLEL_SQL_B, source: 'shop' }) }, 0.03)
ev('node.finished', 'q_a', { duration_ms: 45, attempt: 1 })
ev('node.finished', 'q_b', { duration_ms: 35, attempt: 1 })
ev('node.started', 'card', { node_type: 'metrics', label: '订单口径' })
ev('log', 'card', { level: 'warn', code: 'metric_sql_check', metric: 'gmv', metrics: ['gmv', 'aov'],
metric_names: ['订单金额', '客单价'], reason: `所依据的查询未通过 SQL 检查(${FANOUT_PROBLEM}),结果不可靠`,
problems: [FANOUT_PROBLEM], checks: [FANOUT_CHECK], query_artifact: 'qs-q_a', source_node: 'q_a', source_field: 'args.sql',
message: `指标「订单金额」「客单价」所依据的查询未通过 SQL 检查(${FANOUT_PROBLEM}),结果不可靠` })
ev('node.finished', 'card', { duration_ms: 3, attempt: 1 })
ev('run.finished', null, { output: {}, timing: { wall_ms: 300, active_ms: 300, wait_ms: 0 } })
return out
}
/** 结构化校验:原文里没有数,修复两次都编出了 total_count=0,两次都作废,判失败 */
export function repairRun(): RunEvent[] {
const { out, ev } = builder('syn-repair')
+107 -55
View File
@@ -2,12 +2,13 @@ import type { CatalogDriftTable, RunEvent, SqlCheckItem, TeamMember, TeamRound,
import type { NodeState, RunPhase } from './trace'
import { formatDuration, formatNumber } from '../lib/format'
import {
CATALOG_DRIFT_TEXT, CATALOG_PATCH_TEXT, JUDGE_TEXT, MERGE_TEXT, SCHEMA_PARTIAL_TEXT, SQL_CHECK_TEXT, TYPE_LABEL, claimTally,
CATALOG_DRIFT_TEXT, CATALOG_PATCH_TEXT, COPILOT_CONTEXT_TEXT, JUDGE_TEXT, MERGE_TEXT, RUN_SQL_CHECK_TEXT, SCHEMA_PARTIAL_TEXT, SQL_CHECK_TEXT, TYPE_LABEL,
claimTally,
evidenceTally, issuanceLabel, nodeTypeLabel,
} from '../lib/terms'
import { catalogPatchOf, patchValueText, patchWhere } from './catalogPatch'
import { claimCountsOf, isJudged, statsTally } from '../lib/evidence'
import { isSqlCheckCode, sortSqlChecks, sqlCheckWhere, sqlRuleLabel } from '../lib/sqlcheck'
import { isSqlCheckCode, sortSqlChecks, sqlCheckOf, sqlChecksOf, sqlCheckWhere, sqlRuleLabel } from '../lib/sqlcheck'
// 泳道数据画布也要用(supervisor 节点要展开成协作矩阵),所以类型放在
// types.ts 里;这里再导出一遍,老引用不用改
@@ -152,6 +153,13 @@ export interface Step {
tier?: string
/** 合并查询那一行(merge.end):合并了哪几个输入、几条警告。SQL 在 detail,预览在 result */
merge?: MergeStep
/** 对照数据目录的 SQL 检查结果:查询那一行(tool.end.checks)、指标所依据的查询没通过检查那一行(log.checks) */
checks?: SqlCheckItem[]
/** fix 要去的不是这一行所在的节点(指标的问题出在来源查询节点的 SQL 上):去哪个节点、落到哪一栏 */
fixNode?: string
fixField?: string
/** fixNode 在画布上的名字(入口写「打开「取数」的 SQL」) */
fixLabel?: string
}
/** 合并查询的一个输入:合并 SQL 里的别名、上游节点、行数、数据源 */
@@ -441,8 +449,10 @@ export interface ResultTable {
rows: unknown[][]
/** 查询本身撞了行数上限——数据库里还有更多,是 guard 没让它全取回来 */
truncated: boolean
/** 这份预览被按字符数切断了——取回来的行数比这里显示的多,只是没存下来 */
/** 这份预览被按字符数切断了,或者本来就只存了前几行——实际的行数比这里显示的多,只是没存下来 */
clipped?: boolean
/** 实际一共几行(结果里的 row_count)。比 rows 多时,表格脚注写「显示前 5 / 6 行」 */
total?: number
}
/**
@@ -477,7 +487,9 @@ function tryTable(text: string): ResultTable | null {
try {
const data = JSON.parse(text)
if (Array.isArray(data?.columns) && Array.isArray(data?.rows)) {
return { columns: data.columns, rows: data.rows, truncated: !!data.truncated }
const total = typeof data.row_count === 'number' && data.row_count > data.rows.length ? data.row_count : undefined
return { columns: data.columns, rows: data.rows, truncated: !!data.truncated,
...(data.clipped === true || total != null ? { clipped: true } : {}), ...(total != null ? { total } : {}) }
}
} catch {
/* 交给调用方决定要不要修 */
@@ -704,7 +716,10 @@ function gateTitle(tool: string, verdict: 'allow' | 'escalate' | 'team', reason:
* 贴出来是一串标记和术语,而且不说该去哪儿改——这里说成人话,并给出下一步。
* 认不得的 code 返回 null,照原话显示
*/
function explainLog(code: string | undefined, message: string): Pick<Step, 'title' | 'sub' | 'next' | 'fix'> | null {
function explainLog(code: string | undefined, message: string, d: Record<string, any> = {},
): Pick<Step, 'title' | 'sub' | 'next' | 'fix' | 'fixNode' | 'fixField' | 'checks'> | null {
const str = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined)
const strs = (v: unknown): string[] => (Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string' && !!x) : [])
switch (code) {
case 'tool_markup_leak': {
// 「数据查询把工具调用写成了文字(<||DSML||…),没有真正调用工具,已提醒它重试一次」
@@ -770,28 +785,34 @@ function explainLog(code: string | undefined, message: string): Pick<Step, 'titl
}
}
case 'metric_incomplete': {
// 「指标「入园人次」基于被截断的查询结果计算(只取回了前 1000 行),结果不完整」(metrics.py _incomplete_reason)
const name = message.match(/^指标「(.+?)」/)?.[1]
// 结构化字段(metrics.py):metric_name、reason(「基于被截断的查询结果计算(只取回了前 1000 行),结果不完整」)。
// 老运行的日志没有这两个字段:只给不点名的标题,原话留在展开区,不从中文里解析
const name = str(d.metric_name)
const reason = str(d.reason)?.replace(/,结果不完整$/, '')
return {
title: name ? `指标「${name}」结果不完整` : '指标结果不完整',
sub: message.match(/^指标「.+?」(.+?),结果不完整$/)?.[1],
sub: reason,
next: '口径卡对截断的查询结果计数、求和,只算到了取回的部分,出具按缺口降档。'
+ '请在 SQL 中直接聚合(如 COUNT、SUM)或缩小查询范围后重新运行',
fix: 'canvas',
}
}
case 'metric_sql_check': {
// 「指标「客单价」所依据的查询未通过 SQL 检查(「订单」关联「订单明细」是一对多,对「订单」的「订单金额」求和会
// 重复计算),结果不可靠」;几处时是「所依据的查询有 2 处未通过 SQL 检查(…等),结果不可靠」(metrics.py
// _sql_check_reason)。括号里的问题本身可能带括号:取到「,结果不可靠」前面最后一个右括号
const name = message.match(/^指标「(.+?)」/)?.[1]
const n = message.match(/有\s*(\d+)\s*处未通过 SQL 检查/)?.[1]
const why = message.match(/未通过 SQL 检查(([\s\S]+))[,,]\s*结果不可靠\s*$/)?.[1]
// 一条没通过 SQL 检查的来源查询一行(metrics.py _emit_sql_check_logs),结构化字段:metric_names(受影响的指标)、
// problems(问题那半句)、checks(级别、规则、表和列)、source_node / source_field(来源查询节点和它的 SQL 那一栏)。
// 「打开设置」落到来源查询节点的 SQL 上:要改的是那条 SQL,不是口径卡。老运行没有这些字段:只给不点名的标题
const names = strs(d.metric_names)
const problems = strs(d.problems)
const checks = sqlChecksOf(d.checks)
const source = str(d.source_node)
return {
title: name ? SQL_CHECK_TEXT.metricTitle(name, n ? Number(n) : 1) : SQL_CHECK_TEXT.metricTitleAnon,
sub: why,
next: SQL_CHECK_TEXT.metricNext,
title: names.length ? RUN_SQL_CHECK_TEXT.metricsTitle(names, Math.max(1, problems.length)) : SQL_CHECK_TEXT.metricTitleAnon,
sub: problems.join(';') || undefined,
next: source ? RUN_SQL_CHECK_TEXT.metricNext : SQL_CHECK_TEXT.metricNext,
fix: 'canvas',
...(source ? { fixNode: source } : {}),
...(source && str(d.source_field) ? { fixField: str(d.source_field) } : {}),
...(checks.length ? { checks } : {}),
}
}
case 'judge_limit': {
@@ -805,33 +826,33 @@ function explainLog(code: string | undefined, message: string): Pick<Step, 'titl
}
}
case 'merge_key_type': {
// 「合并键类型不一致:s.门店 是文本(例如 '01'),v.门店 是数值(例如 1)。SQLite 比较时会做隐式转换…」
// (engine/merge_query._warnings)。标题说是哪两列,副标题说各是什么类型
const m = message.match(/^合并键类型不一致[::]\s*(.+?)。/)
const keys = [...(m?.[1] ?? '').matchAll(/([\w一-龥]+\.[^\s,,]+)\s*是/g)].map((x) => x[1])
// 结构化字段(engine/merge_query._warnings):keys(两边的列)、detail(「s.门店 是文本(例如 '01'),v.门店 是数值(例如 1)」)
const keys = strs(d.keys)
return {
title: keys.length === 2 ? `合并键类型不一致:${keys[0]} 与 ${keys[1]}` : '合并键类型不一致',
sub: m?.[1],
sub: str(d.detail),
next: '两边类型不同时,SQLite 按隐式转换比较,可能错配或完全匹配不上。请在源查询中统一类型,或在合并 SQL 中用 CAST 明确转换',
fix: 'canvas',
}
}
case 'merge_rows_grew': {
// 「合并结果有 8 行,多于行数最多的输入「s」(4 行):合并键可能不唯一,同一行被重复匹配。…」
const head = message.match(/^合并结果有\s*([\d,]+)\s*行,多于行数最多的输入「(.+?)」(([\d,]+)\s*行)/)
const dup = message.match(/重复匹配。(.+?)。请检查/)?.[1]
// 结构化字段:rows(合并结果行数)、input / input_rows(行数最多的输入)、duplicates(各输入里重复的键)
const rows = num(d.rows)
const input = str(d.input)
const inputRows = num(d.input_rows)
return {
title: '合并结果行数多于输入,合并键可能不唯一',
sub: [head ? `合并结果 ${head[1]} 行,行数最多的输入「${head[2]}」${head[3]} 行` : '', dup ?? '']
.filter(Boolean).join(';') || undefined,
sub: [rows != null && input && inputRows != null
? `合并结果 ${formatNumber(rows)} 行,行数最多的输入「${input}」${formatNumber(inputRows)} 行` : '',
str(d.duplicates) ?? ''].filter(Boolean).join(';') || undefined,
next: '请检查合并条件是否覆盖了全部合并键(例如同时按日期和门店),或先在源库里聚合到相同粒度',
fix: 'canvas',
}
}
case 'merge_truncated': {
const rows = message.match(/只保留了前\s*([\d,]+)\s*行/)?.[1]
const rows = num(d.rows)
return {
title: `合并结果超过上限,${rows ? `只保留了前 ${rows} 行` : '已截断'}`,
title: `合并结果超过上限,${rows != null ? `只保留了前 ${formatNumber(rows)} 行` : '已截断'}`,
next: '下游拿到的不是完整结果。请在合并 SQL 中聚合或加条件缩小范围',
fix: 'canvas',
}
@@ -895,6 +916,12 @@ function explainLog(code: string | undefined, message: string): Pick<Step, 'titl
}
}
/** tool.start / tool.end 的配对键:有 call_id 用它;独立的调用工具节点不带 call_id,用「节点 + 工具名」 */
function toolKey(nodeId: string | undefined, d: Record<string, any>, seq?: number): string {
if (d.call_id) return `call:${String(d.call_id)}`
return `${nodeId ?? '_'}:${String(d.tool || (seq ?? ''))}`
}
function toolStep(seq: number, tool: string, args: Record<string, any>): Step {
const base = { id: `tool-${seq}`, seq, status: 'running' as StepStatus }
// 数据库工具单独认:它是这个产品最主要的取数方式,"调用 db_query__warehouse"
@@ -1629,15 +1656,16 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
// 协作成员调的工具说清是谁调的
if (d.agent) step.sub = `${d.agent} 调用`
// call_id 才是可靠的配对键:同一节点并发调同名工具时,按名字配会错位。
// 独立 Tool 节点不带 call_id,回退到工具名。
pendingTools.set(String(d.call_id || d.tool || seq), step)
// 独立 Tool 节点不带 call_id,回退到「节点 + 工具名」:两个并行的查询节点用同一个工具时,
// 只按工具名配,后开始的那条会顶掉先开始的,结果配错节点
pendingTools.set(toolKey(nodeId, d, seq), step)
push(step, nodeId)
break
}
case 'tool.end':
case 'tool.error': {
const key = String(d.call_id || d.tool || '')
const key = toolKey(nodeId, d)
const step = pendingTools.get(key)
const preview = String(d.preview ?? d.error ?? '')
if (step) {
@@ -1662,6 +1690,16 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
step.meta = parts.join(' · ') || undefined
step.artifact = d.artifact
if (typeof d.detail === 'string' && d.detail) step.raw = d.detail
// 这次查询对照数据目录的 SQL 检查(tool.end.checks):preview 只是结果的前一截,检查结果通常被截掉,单独带着。
// 副标题数一下错误、提醒、提示,展开看每一条
const checks = sqlChecksOf(d.checks)
if (checks.length && !failed) {
step.checks = sortSqlChecks(checks)
const n = (lv: string) => checks.filter((c) => c.level === lv).length
const counts = SQL_CHECK_TEXT.assistantTitle(SQL_CHECK_TEXT.counts(n('error'), n('warning'), n('info')))
step.sub = step.sub ? `${step.sub} · ${counts}` : counts
if (n('error') || n('warning')) step.level = 'warn'
}
if (step.kind === 'query' || step.kind === 'schema' || failed) {
// 查询保留 SQL 作为 detail,结果另挂;失败时结果就是错误原因
step.detail = failed ? `${step.detail ?? ''}\n\n${preview}`.trim() : step.detail
@@ -2051,7 +2089,7 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
// 其余 info 是给排查用的,不进主流程——但 warn/error 用户必须看到
if (level === 'info' || !message) break
const code = typeof d.code === 'string' && d.code ? d.code : undefined
const said = explainLog(code, message)
const said = explainLog(code, message, d)
if (code === 'repair_invented') {
// 修复编出了原文没有的值:折进刚才那一行「让模型修复格式」,一件事一行
const repair = repairs.get(nodeId ?? '_')
@@ -2063,12 +2101,14 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
}
}
if (code === 'team_exhausted') trackTeam(event)
// 要改的是另一个节点(来源查询):入口写它的名字,认不出就只写「打开来源查询的 SQL」
const fixLabel = said?.fixNode ? nodeSteps.get(said.fixNode)?.title : undefined
push({
id: `lg-${seq}`, seq, kind: 'note', nodeId, status: 'done',
level: level === 'error' ? 'error' : 'warn',
...(code ? { code } : {}),
...(said
? { ...said, detail: message }
? { ...said, detail: message, ...(fixLabel ? { fixLabel } : {}) }
: { title: clip(message, 120), ...(message.length > 120 ? { detail: message } : {}) }),
}, nodeId)
break
@@ -2187,8 +2227,11 @@ export function decodeRun(events: RunEvent[], final?: RunFinal, opts?: DecodeOpt
...(warnings ? { level: 'warn' as const, sub: MERGE_TEXT.warnings(warnings) } : {}),
title: MERGE_TEXT.stepTitle(inputs.map((i) => i.alias)),
detail: typeof d.sql === 'string' && d.sql ? d.sql : undefined,
// 预览只存了前几行:那是「此处仅为预览」(clipped),不是「查询已达行数上限」(truncated)。
// 合并结果本身超过上限才是 truncated;row_count 记全部行数,表格脚注写「显示前 5 / 6 行」
result: Array.isArray(d.columns)
? JSON.stringify({ columns: d.columns, rows: preview, truncated: rows != null && rows > preview.length })
? JSON.stringify({ columns: d.columns, rows: preview, truncated: !!d.truncated,
clipped: rows != null && rows > preview.length, ...(rows != null ? { row_count: rows } : {}) })
: undefined,
meta: [rows != null ? MERGE_TEXT.rows(rows) : '', dur(ms) ?? ''].filter(Boolean).join(' · ') || undefined,
ms,
@@ -2472,10 +2515,8 @@ export interface CopilotIssue {
code?: string
/** error / warning / info。老会话、老后端不给 */
level?: 'error' | 'warning' | 'info'
/** SQL 检查的问题另带:涉及的表和列、SQL 片段 */
table?: string
column?: string
sqlExcerpt?: string
/** SQL 检查的问题按检查读出来的那一条(lib/sqlcheck 的 sqlCheckOf:级别、规则、表和列、关系编号、SQL 片段) */
sql?: SqlCheckItem
}
/**
@@ -2491,15 +2532,16 @@ function parseIssue(v: unknown, labels?: (id: string) => string | undefined): Co
if (v && typeof v === 'object') {
const o = v as Record<string, unknown>
const str = (x: unknown) => (typeof x === 'string' && x ? x : undefined)
// SQL 检查和证据面板、运行时间线同一个读法(sqlCheckOf,关系编号也留着)。自查交回模型改的问题老后端不给级别,
// 那时交回去的都是错误:没给级别的按错误读
const sql = isSqlCheckCode(o.code) ? sqlCheckOf({ ...o, level: o.level ?? 'error' }) : null
return named({
message: String(o.message ?? ''),
...(o.node_id ? { nodeId: String(o.node_id) } : {}),
...(str(o.field) ? { field: str(o.field) } : {}),
...(str(o.code) ? { code: str(o.code) } : {}),
...(o.level === 'error' || o.level === 'warning' || o.level === 'info' ? { level: o.level } : {}),
...(str(o.table) ? { table: str(o.table) } : {}),
...(str(o.column) ? { column: str(o.column) } : {}),
...(str(o.sql_excerpt) ? { sqlExcerpt: str(o.sql_excerpt) } : {}),
...(sql ? { sql } : {}),
})
}
const text = String(v ?? '')
@@ -2512,20 +2554,16 @@ function parseIssue(v: unknown, labels?: (id: string) => string | undefined): Co
* 不露规则编号
*/
export const issueLine = (x: CopilotIssue): string => {
const where = isSqlCheckCode(x.code) ? sqlCheckWhere({ table: x.table ?? '', column: x.column }) : ''
const body = isSqlCheckCode(x.code)
? `${sqlRuleLabel(x.code)}:${x.message}${where ? `(${SQL_CHECK_TEXT.where} ${where})` : ''}`
const where = x.sql ? sqlCheckWhere(x.sql) : ''
const body = x.sql
? `${sqlRuleLabel(x.sql.code)}:${x.message}${where ? `(${SQL_CHECK_TEXT.where} ${where})` : ''}`
: x.message
return x.nodeId ? `「${x.label ?? x.nodeId}」${body}` : body
}
/** 一条自查问题按 SQL 检查读(界面上画级别、规则名、表和列、SQL 片段);不是 SQL 检查的返回 null */
export function issueSqlCheck(x: CopilotIssue): SqlCheckItem | null {
if (!isSqlCheckCode(x.code)) return null
return {
code: x.code, level: x.level ?? 'error', message: x.message, table: x.table ?? '',
...(x.column ? { column: x.column } : {}), ...(x.sqlExcerpt ? { sql_excerpt: x.sqlExcerpt } : {}),
}
return x.sql ?? null
}
/** final.issues 里对照数据目录的 SQL 检查结果(不挡运行的提醒、提示也在里面);自查没修好、已经列过的错误不再算 */
@@ -2665,26 +2703,40 @@ function contextLine(g: CopilotContextSource): string {
* 标题直说只给了表名,原因放在展开区。认不出的形状返回 null:不出这一行,也不报错。
*/
export function copilotContext(op: CopilotOp): { title: string; sub?: string; detail: string; ms?: number } | null {
const groups = contextSources(op)
// 展开区里按需求挑过表的库排在前面:请求里点名的那个库往往就是它,排在一串小库后面得在内层滚动框里翻才看得到
const order: Record<CopilotContextSource['selectedBy'], number> = { model: 0, all: 1, fallback: 2 }
const groups = contextSources(op).map((g, i) => ({ g, i }))
.sort((a, b) => order[a.g.selectedBy] - order[b.g.selectedBy] || a.i - b.i).map((x) => x.g)
if (!groups.length) return null
// 两个数分开说:带着全部字段的表(count),和只提供了表名的表(namesOnly:没挑成的库、一张没挑中的库)。
// 以前标题只写前者,「参考了 26 张表」看不出另有 206 张只给了表名
const count = groups.reduce((n, g) => n + g.tables.length, 0)
const namesOnly = groups.reduce((n, g) => n + namesOnlyOf(g), 0)
const failed = groups.filter((g) => g.selectedBy === 'fallback')
// 有表带着字段(小库,或者现有工作流用到的表)时标题仍说几张,没挑成的事放副标题
const who = failed.length && failed.length < groups.length ? `「${failed.map((g) => g.source).join('」「')}」` : ''
const sub = count && failed.length
? failed.length === groups.length ? CONTEXT_FALLBACK_TEXT
: `「${failed.map((g) => g.source).join('」「')}」${CONTEXT_FALLBACK_TEXT}`
: undefined
? namesOnly ? `${who}${COPILOT_CONTEXT_TEXT.notPicked},${COPILOT_CONTEXT_TEXT.namesOnly(namesOnly)}` : `${who}${CONTEXT_FALLBACK_TEXT}`
: count && namesOnly ? COPILOT_CONTEXT_TEXT.namesOnly(namesOnly) : undefined
const reasons = [...new Set(failed.map((g) => g.reason).filter(Boolean))]
// 挑过表才有 elapsed_ms:挑表是生成之前多出来的一次模型调用,没挑成(比如超时)也要让人看到等了多久
const ms = num(op.elapsed_ms)
return {
title: count ? `参考了 ${count} 张表` : CONTEXT_FALLBACK_TEXT,
title: count ? (namesOnly ? COPILOT_CONTEXT_TEXT.withFields(count) : `参考了 ${count} 张表`) : CONTEXT_FALLBACK_TEXT,
...(sub ? { sub } : {}),
detail: [...groups.map(contextLine), ...reasons.map((r) => `原因:${r}`)].join('\n'),
...(ms != null && ms >= 10 ? { ms } : {}),
}
}
/** 这个库里只提供了表名、没带字段的表有几张(模型看得到的那些:探查截断了的按探查到的算) */
function namesOnlyOf(g: CopilotContextSource): number {
const seen = g.explored ?? g.total
if (seen == null) return 0
if (g.selectedBy === 'fallback' || (g.selectedBy === 'model' && !g.tables.length)) return Math.max(0, seen - g.tables.length)
return 0
}
/** 用了限定范围之外的数据源:自查交回模型改也改不掉时,人要知道是范围的事,不是图写错了 */
const OUT_OF_SCOPE_NEXT = '本轮限定了查询的数据源,但工作流使用了范围之外的数据库。请取消限定后重新提问,或将所需数据库加入查询范围'
+47 -2
View File
@@ -2108,6 +2108,32 @@ export interface EvidenceMergeInput {
source?: string | null
artifact?: string | null
sealed?: boolean
/** 这个输入查询对照数据目录查出的问题(形状同查询步骤的 checks)。没查出问题、快照读不出来时没有这个键 */
checks?: SqlCheckItem[]
}
/**
* 出具声明(output._issuance、issuance 事件)里的 sql_checks:没通过 SQL 检查的查询,一条一个。报告页、出具横幅据此
* 在显眼处说「因为 SQL 检查没通过而降档」。gap 是 gaps 里对应的那一句(单列之后不在其余缺口里重复)
*/
export interface IssuanceSqlCheck {
/** 「查询「取数」(Q1)」;给不出时没有 */
query?: string
node_id?: string
/** 每条问题那半句 */
problems?: string[]
/** 受影响的引用:「指标「订单金额」」「Q1 第 1 行「gmv」」 */
refs?: string[]
gap?: string
}
/** 查询用到的一张表、查询当时它的数据目录版本 */
export interface EvidenceCatalogVersion {
/** 表结构里的表名 */
table: string
/** 目录里的中文名 */
label?: string
version?: number | null
}
/** 被引用的一格追到了哪个输入的哪一格;追不到时 input 为空,note 说明只有表级来历 */
@@ -2166,6 +2192,10 @@ export interface EvidenceStep extends Omit<EvidenceInput, 'status'> {
sql_check_reason?: string
/** query:这次查询对照数据目录查出的问题。没查出问题时没有这个键 */
checks?: SqlCheckItem[]
/** query:查询当时冻结的表结构快照(工件 id)。合并查询、老快照没有 */
schema_artifact?: string
/** query:这条查询用到的表在表结构快照里冻结的数据目录版本(SQL 检查对照的那一版)。没有目录时没有这个键 */
catalog?: EvidenceCatalogVersion[]
inputs?: EvidenceInput[]
/** 口径卡钉在哪个工作流的哪一版(metric;方案第 5 节的写法,接口实际给在 source 上) */
caliber_from?: EvidenceCaliberSource | null
@@ -2622,6 +2652,11 @@ export interface CatalogRelation {
status: CatalogStatus
note?: string
updated_at?: string
/**
* 基数是数据剖析用数据核实的(子表一侧数过是否唯一),只由剖析写。外键、命名推断的基数没有这个键。
* 一对多关联后重复计算的检查只在它为真、或者关系人工确认过时报「错误」,否则最多是「提醒」
*/
cardinality_checked?: boolean
}
/** 一张表的目录(notes)。字段固定,服务端不认识的一律拒收 */
@@ -2731,8 +2766,13 @@ export interface CatalogDraftRow {
version: number
/** 这张表没有起草(表结构里没有、写入一直冲突) */
error: string | null
/** 只是模型那部分失败,其余来源照常写入 */
/** 只是模型那部分失败,其余来源照常写入。模型给了这张表、却一项可用内容都没有,也记在这里 */
model_error: string | null
/**
* 模型给了这张表几项可用内容(并入目录之前)。没用模型、模型这部分失败时为 null(老后端没有这个键)。
* 大于 0 而新增、更新、删除都是 0,才是「模型给了内容、只是和现有目录一致」
*/
model_items?: number | null
}
/** POST /datasources/{id}/catalog/draft */
@@ -2922,6 +2962,11 @@ export interface CatalogProfileOut {
stopped: CatalogProfileStop | null
tables: CatalogProfileTable[]
total: { added: number; updated: number; removed: number }
/**
* 不指定表时,挑表途中估过行数、确知是空表而跳过的表(老后端没有这个键;指定了表时是空列表)。
* 估行数的查询算在 queries_used 里,不算在各表的 queries 里
*/
empty_tables?: string[]
/** 一张表都没有剖析时的说明 */
note: string | null
}
@@ -2933,7 +2978,7 @@ export interface CatalogProfileOut {
export type SqlCheckCode = 'fanout_sum' | 'stock_summed' | 'join_unconfirmed' | 'ratio_aggregated' | 'missing_valid_filter'
| 'unknown_code' | 'wrong_date_column'
/** error:依据有确证、结果必然有误;warning:依据有确证、很可能有误;info:依据只是推断 */
/** error:依据已核实、结果很可能有误;warning:依据有确证、结果可能有误;info:依据只是推断 */
export type SqlCheckLevel = 'error' | 'warning' | 'info'
/** 一条检查结果(证据接口查询步骤里的 checks、助手自查和发布前检查的问题)。交回模型改写用的那句不上界面,这里不收 */