diff --git a/frontend/src/dev/preview.tsx b/frontend/src/dev/preview.tsx index 186ece6a..a279c684 100644 --- a/frontend/src/dev/preview.tsx +++ b/frontend/src/dev/preview.tsx @@ -15,7 +15,7 @@ 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, + markupRun, mergeRun, mixedRun, parallelQueryRun, pipelineRun, repairRun, teamRun, timeoutRun, } from '../run/__tests__/synthetic' import '../index.css' @@ -364,6 +364,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 +537,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' ? 重试本轮 : null)} diff --git a/frontend/src/lib/sqlcheck.ts b/frontend/src/lib/sqlcheck.ts index bc1b9a1d..546bc669 100644 --- a/frontend/src/lib/sqlcheck.ts +++ b/frontend/src/lib/sqlcheck.ts @@ -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) diff --git a/frontend/src/run/AssistantPanel.tsx b/frontend/src/run/AssistantPanel.tsx index 52cbb532..6b499f79 100644 --- a/frontend/src/run/AssistantPanel.tsx +++ b/frontend/src/run/AssistantPanel.tsx @@ -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} diff --git a/frontend/src/run/AssistantStream.tsx b/frontend/src/run/AssistantStream.tsx index 012349ed..cca9f80a 100644 --- a/frontend/src/run/AssistantStream.tsx +++ b/frontend/src/run/AssistantStream.tsx @@ -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, @@ -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 ( - onOpen(nodeId)}> - 打开{label ? `「${label}」的` : ''}设置 + onOpen(nodeId, field || undefined)}> + {sql ? RUN_SQL_CHECK_TEXT.openSql(label) : `打开${label ? `「${label}」的` : ''}设置`} ) } @@ -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?: {step.next} - + {/* 要改的是另一个节点(指标的问题出在来源查询的 SQL 上):入口落到那个节点的那一栏 */} + )} @@ -1518,6 +1525,13 @@ function StepDetail({ step, table, explained }: { )} + {!!step.checks?.length && ( + // 对照数据目录的 SQL 检查:查询那一行是这次查询的检查结果,指标那一行是来源查询没通过的那几条 + + {RUN_SQL_CHECK_TEXT.toolChecks} + + + )} {table ? : result && result !== step.detail && ( diff --git a/frontend/src/run/__tests__/synthetic.ts b/frontend/src/run/__tests__/synthetic.ts index ab4cc518..cfee2d4b 100644 --- a/frontend/src/run/__tests__/synthetic.ts +++ b/frontend/src/run/__tests__/synthetic.ts @@ -365,15 +365,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') diff --git a/frontend/src/run/decode.ts b/frontend/src/run/decode.ts index bae580bb..cd668956 100644 --- a/frontend/src/run/decode.ts +++ b/frontend/src/run/decode.ts @@ -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, COPILOT_CONTEXT_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 里的别名、上游节点、行数、数据源 */ @@ -708,7 +716,10 @@ function gateTitle(tool: string, verdict: 'allow' | 'escalate' | 'team', reason: * 贴出来是一串标记和术语,而且不说该去哪儿改——这里说成人话,并给出下一步。 * 认不得的 code 返回 null,照原话显示 */ -function explainLog(code: string | undefined, message: string): Pick | null { +function explainLog(code: string | undefined, message: string, d: Record = {}, +): Pick | 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||…),没有真正调用工具,已提醒它重试一次」 @@ -774,28 +785,34 @@ function explainLog(code: string | undefined, message: string): Pick 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', } @@ -899,6 +916,12 @@ function explainLog(code: string | undefined, message: string): Pick, 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): Step { const base = { id: `tool-${seq}`, seq, status: 'running' as StepStatus } // 数据库工具单独认:它是这个产品最主要的取数方式,"调用 db_query__warehouse" @@ -1633,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) { @@ -1666,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 @@ -2055,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 ?? '_') @@ -2067,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 @@ -2479,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 } /** @@ -2498,15 +2532,16 @@ function parseIssue(v: unknown, labels?: (id: string) => string | undefined): Co if (v && typeof v === 'object') { const o = v as Record 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 ?? '') @@ -2519,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 检查结果(不挡运行的提醒、提示也在里面);自查没修好、已经列过的错误不再算 */ diff --git a/scripts/check-decode.mjs b/scripts/check-decode.mjs index db2b642b..c3ef2f87 100644 --- a/scripts/check-decode.mjs +++ b/scripts/check-decode.mjs @@ -133,11 +133,19 @@ await section('合并查询', async () => { check('工件可下钻到合并结果的快照', m?.artifact === 'mq-merge') check('有警告时这一行标成警告、说有几条', m?.level === 'warn' && !!m.sub?.includes('2 条警告'), m?.sub) const key = all.find((s) => s.code === 'merge_key_type') - check('键类型不一致说成人话:标题点名两列', !!key?.title.includes('s.门店') && key.title.includes('v.门店'), key?.title) + check('键类型不一致说成人话:标题点名两列(读 keys 字段)', key?.title === '合并键类型不一致:s.门店 与 v.门店', key?.title) + check('……副标题是 detail 字段', key?.sub === "s.门店 是文本(例如 '01'),v.门店 是数值(例如 1)", key?.sub) check('键类型不一致给出下一步', !!key?.next?.includes('CAST') && key.fix === 'canvas') const grew = all.find((s) => s.code === 'merge_rows_grew') - check('行数放大说成人话,并带上行数和重复的键', !!grew?.title.includes('不唯一') && !!grew.sub?.includes('8 行') - && !!grew.sub?.includes('出现 2 次'), grew?.sub) + check('行数放大说成人话,并带上行数和重复的键(读 rows、input、input_rows、duplicates 字段)', !!grew?.title.includes('不唯一') + && grew.sub === '合并结果 8 行,行数最多的输入「s」4 行;「s」中按(门店)有重复的键,例如 01 出现 2 次等 2 组;「v」中按(门店)有重复的键,例如 1 出现 2 次等 2 组', + grew?.sub) + // 老运行的日志没有结构化字段:不从中文里解析,只给标题,原话留在展开区 + const old = flatten(mod.decodeRun([ + { seq: 1, type: 'node.started', node_id: 'merge', ts: 1, data: { node_type: 'merge' } }, + { seq: 2, type: 'log', node_id: 'merge', ts: 2, data: { level: 'warn', code: 'merge_key_type', message: '合并键类型不一致:s.门店 是文本,v.门店 是数值。' } }, + ])).find((s) => s.code === 'merge_key_type') + check('老日志没有结构化字段:只给标题,不解析原话', old?.title === '合并键类型不一致' && !old.sub && !!old.detail?.includes('s.门店'), old?.title) check('警告原文各占一行,不在合并那一行里重复', all.filter((s) => s.level === 'warn' && s.nodeId === 'merge').length === 3) check('合并节点照常完成,两次源查询仍是普通查询步骤', all.filter((s) => s.kind === 'query' && s.code !== 'merge').length === 2 && steps.find((s) => s.nodeId === 'merge')?.status === 'done') @@ -1484,16 +1492,17 @@ await section('agent 字段按出处核对(可点击证据第二期):抽 await section('口径卡指标不完整(数据目录阶段 0):截断的查询结果整组拿来算的指标,警告说人话并指到 SQL', async () => { const E = (seq, type, node_id, data = {}) => ({ seq, type, node_id, ts: 1790000000 + seq, data }) - // 原话和 backend/app/engine/nodes/metrics.py 的 _incomplete_reason 同一个句式。先核对后端源码还是这么说的 - const INCOMPLETE = '指标「入园人次」基于被截断的查询结果计算(只取回了前 1000 行),结果不完整' + // 日志带着结构化字段(metric_name、reason),界面读字段,不从原话里解析。先核对后端还发这两个字段 + const REASON = '基于被截断的查询结果计算(只取回了前 1000 行),结果不完整' + const INCOMPLETE = `指标「入园人次」${REASON}` const metricsPy = readFileSync(`${root}backend/app/engine/nodes/metrics.py`, 'utf8') - check('后端发指标不完整警告的格式还是夹具里这一种', metricsPy.includes('code="metric_incomplete"') - && metricsPy.includes('message=f"指标「{m[\'name\']}」{m[\'incomplete_reason\']}"') - && metricsPy.includes('f"基于被截断的查询结果计算(只取回了{fetched[0]}),结果不完整"'), - '改了 metrics.py 的说法就同步改 decode.ts 的 explainLog 和这里的夹具') + check('后端发指标不完整警告时带着 metric_name、reason 字段', metricsPy.includes('code="metric_incomplete"') + && metricsPy.includes('metric_name=m["name"]') && metricsPy.includes('reason=m["incomplete_reason"]'), + '改了 metrics.py 的字段就同步改 decode.ts 的 explainLog 和这里的夹具') const all = flatten(mod.decodeRun([ E(1, 'node.started', 'card', { node_type: 'metrics' }), - E(2, 'log', 'card', { level: 'warn', code: 'metric_incomplete', metric: 'visits', message: INCOMPLETE }), + E(2, 'log', 'card', { level: 'warn', code: 'metric_incomplete', metric: 'visits', metric_name: '入园人次', reason: REASON, + rows: [1000], message: INCOMPLETE }), E(3, 'node.finished', 'card', { duration_ms: 3 }), ])) const inc = all.find((s) => s.code === 'metric_incomplete') @@ -1502,6 +1511,12 @@ await section('口径卡指标不完整(数据目录阶段 0):截断的查 `${inc?.sub} / ${inc?.detail}`) check('……是提醒(warn),下一步指到 SQL,节点本身照样成功', inc?.level === 'warn' && !!inc?.next?.includes('SQL') && all.find((s) => s.kind === 'node')?.status === 'done', `${inc?.level} ${inc?.next}`) + const bare = flatten(mod.decodeRun([ + E(1, 'node.started', 'card', { node_type: 'metrics' }), + E(2, 'log', 'card', { level: 'warn', code: 'metric_incomplete', metric: 'visits', message: INCOMPLETE }), + ])).find((s) => s.code === 'metric_incomplete') + check('老日志没有结构化字段:只给不点名的标题,不解析原话', bare?.title === '指标结果不完整' && !bare.sub && bare.detail === INCOMPLETE, + bare?.title) }) await section('结论句裁判(可点击证据第四期):裁判调用单独成行、几条警告说人话、封存后按需裁判有记录', async () => { @@ -1781,45 +1796,44 @@ await section('按后端原文匹配的地方:后端现在的原文、整改 await section('SQL 检查(数据目录阶段 4B):指标所依据的查询未通过检查说成一行;助手自查和交付的问题写中文规则名', async () => { const E = (seq, type, node_id, data = {}) => ({ seq, type, node_id, ts: 1790000000 + seq, data }) - // 原话和 backend/app/engine/nodes/metrics.py 的 _sql_check_reason 同一个句式。先核对后端源码还是这么说的 + // 日志按查询归并(同一条查询的问题一行),带着结构化字段:metric_names、problems、checks、source_node、source_field。 + // 界面读字段,不从原话里解析。先核对后端还发这些字段 const metricsPy = readFileSync(`${root}backend/app/engine/nodes/metrics.py`, 'utf8') - check('后端发指标未通过 SQL 检查警告的格式还是夹具里这几种', metricsPy.includes('code="metric_sql_check"') - && metricsPy.includes('message=f"指标「{m[\'name\']}」{m[\'sql_check_reason\']}"') - && metricsPy.includes('"所依据的查询未通过 SQL 检查,结果不可靠"') - && metricsPy.includes('f"所依据的查询未通过 SQL 检查({problems[0]}),结果不可靠"') - && metricsPy.includes('f"所依据的查询有 {len(problems)} 处未通过 SQL 检查({problems[0]}等),结果不可靠"'), - '改了 metrics.py 的说法就同步改 decode.ts 的 explainLog 和这里的夹具') + check('后端发指标未通过 SQL 检查的日志时带着结构化字段', metricsPy.includes('code="metric_sql_check"') + && ['metrics=ids', 'metric_names=', 'problems=problem.problems', 'checks=', 'source_node', 'source_field'].every((k) => metricsPy.includes(k)), + '改了 metrics.py 的字段就同步改 decode.ts 的 explainLog 和这里的夹具') const CODES = /fanout_sum|stock_summed|join_unconfirmed|ratio_aggregated|missing_valid_filter|unknown_code|wrong_date_column/ - const decodeOne = (message) => { + const decodeOne = (fields) => { const all = flatten(mod.decodeRun([ E(1, 'node.started', 'card', { node_type: 'metrics' }), - E(2, 'log', 'card', { level: 'warn', code: 'metric_sql_check', metric: 'aov', message }), + E(2, 'log', 'card', { level: 'warn', code: 'metric_sql_check', metric: 'aov', ...fields }), E(3, 'node.finished', 'card', { duration_ms: 3 }), ])) return { step: all.find((s) => s.code === 'metric_sql_check'), node: all.find((s) => s.kind === 'node') } } - // 问题本身带括号(列的中文名里写了单位):副标题要取到「,结果不可靠」前面最后一个右括号 - const ONE = '指标「客单价」所依据的查询未通过 SQL 检查(「订单」关联「订单明细」是一对多,对「订单」的「订单金额(元)」求和会重复计算),结果不可靠' - const one = decodeOne(ONE) + // 问题本身带括号(列的中文名里写了单位):读字段就不存在截断的问题 + const P1 = '「订单」关联「订单明细」是一对多,对「订单」的「订单金额(元)」求和会重复计算' + const ONE = `指标「客单价」所依据的查询未通过 SQL 检查(${P1}),结果不可靠` + const one = decodeOne({ metric_names: ['客单价'], problems: [P1], message: ONE }) check('metric_sql_check 一行:标题点名哪个指标', one.step?.title === '指标「客单价」所依据的查询未通过 SQL 检查', one.step?.title) - check('……原因放副标题(问题里的括号不截断),原话留在展开区', - one.step?.sub === '「订单」关联「订单明细」是一对多,对「订单」的「订单金额(元)」求和会重复计算' && one.step?.detail === ONE, + check('……原因放副标题(读 problems 字段),原话留在展开区', one.step?.sub === P1 && one.step?.detail === ONE, `${one.step?.sub} / ${one.step?.detail}`) check('……是提醒(warn),下一步指到 SQL 和数据目录,节点本身照样成功', one.step?.level === 'warn' && !!one.step?.next?.includes('SQL') && !!one.step?.next?.includes('数据目录') && one.step?.fix === 'canvas' && one.node?.status === 'done', `${one.step?.level} ${one.step?.next}`) - const two = decodeOne('指标「客单价」所依据的查询有 2 处未通过 SQL 检查(「订单」关联「订单明细」是一对多,对「订单」的「订单金额」求和会重复计算等),结果不可靠') - check('几处问题:标题写处数,副标题是第一处', two.step?.title === '指标「客单价」所依据的查询有 2 处未通过 SQL 检查' - && two.step?.sub === '「订单」关联「订单明细」是一对多,对「订单」的「订单金额」求和会重复计算等', `${two.step?.title} / ${two.step?.sub}`) - const bare = decodeOne('指标「客单价」所依据的查询未通过 SQL 检查,结果不可靠') - check('没有括号里的问题:只有标题,不编副标题', bare.step?.title === '指标「客单价」所依据的查询未通过 SQL 检查' && !bare.step?.sub, - `${bare.step?.title} / ${bare.step?.sub}`) + const P2 = '「库存」按日期以外的列求和会把存量跨期加总' + const two = decodeOne({ metric_names: ['客单价', '订单金额'], problems: [P1, P2], message: 'x' }) + check('一条查询两处问题、影响两个指标:标题点名两个指标并写处数,副标题列出两处', two.step?.title === '指标「客单价」「订单金额」所依据的查询有 2 处未通过 SQL 检查' + && two.step?.sub === `${P1};${P2}`, `${two.step?.title} / ${two.step?.sub}`) + const bare = decodeOne({ message: '指标「客单价」所依据的查询未通过 SQL 检查(某个问题),结果不可靠' }) + check('老日志没有结构化字段:只给不点名的标题,不解析原话', bare.step?.title === '指标所依据的查询未通过 SQL 检查' && !bare.step?.sub + && !bare.step?.fixNode, `${bare.step?.title} / ${bare.step?.sub}`) // 助手自查(check)和交付(final.issues)里的 SQL 检查问题:code 是规则编号,field 是 args.sql,另带表、列和 SQL 片段 const sqlIssue = (level, code, message, extra = {}) => ({ level, node_id: 'q', edge_id: null, field: 'args.sql', code, message, table: 'orders', ...extra }) const ERR = sqlIssue('error', 'fanout_sum', '「订单」关联「订单明细」是一对多,对「订单」的「订单金额」求和会重复计算。请先按订单汇总明细再关联', - { column: 'total_amount', sql_excerpt: 'SUM(o.total_amount)' }) + { column: 'total_amount', sql_excerpt: 'SUM(o.total_amount)', relation_id: 'r0a1b2c3d4e5' }) const WARN = sqlIssue('warning', 'missing_valid_filter', '「订单」定义了有效记录条件「status <> 9」,查询中没有按它筛选') const INFO = sqlIssue('info', 'join_unconfirmed', '「订单」与「门店」按推断的关系关联(o.store_id = s.id),这条关系尚未确认', { table: 'stores' }) const ops = [ @@ -1856,6 +1870,8 @@ await section('SQL 检查(数据目录阶段 4B):指标所依据的查询 const asCheck = mod.issueSqlCheck(out.check.issues[0]) check('问题按 SQL 检查读得出级别、表、列、SQL 片段', asCheck?.level === 'error' && asCheck.table === 'orders' && asCheck.column === 'total_amount' && asCheck.sql_excerpt === 'SUM(o.total_amount)' && out.check.issues[0].field === 'args.sql', JSON.stringify(asCheck)) + // 和证据面板、运行时间线同一个读法(lib/sqlcheck 的 sqlCheckOf):关系编号不丢 + check('……关系编号也留着(以前另写的一份丢了 relation_id)', asCheck?.relation_id === 'r0a1b2c3d4e5', JSON.stringify(asCheck)) check('不是 SQL 检查的问题不按它读', mod.issueSqlCheck({ message: 'x', code: 'tools_dropped' }) === null) const infoOnly = mod.decodeCopilot([{ op: 'final', graph: { nodes: [{ id: 'q' }] }, issues: [INFO] }], { context: 'canvas' }) .find((s) => s.code === 'sql_check') @@ -1863,5 +1879,28 @@ await section('SQL 检查(数据目录阶段 4B):指标所依据的查询 `${infoOnly?.level} ${infoOnly?.next}`) }) +await section('并行查询配对(A1)、查询的 SQL 检查(tool.end.checks)、指标的问题指到来源查询的 SQL(B2)', async () => { + const all = flatten(mod.decodeRun(synthetic.parallelQueryRun(), { status: 'succeeded' })) + const qa = all.find((s) => s.kind === 'query' && s.nodeId === 'q_a') + const qb = all.find((s) => s.kind === 'query' && s.nodeId === 'q_b') + check('两个并行的查询节点用同一个工具:各自的结果配回各自的节点', !!qa?.result?.includes('119160') && !!qb?.result?.includes('"refunds"') + && !qb.result.includes('119160'), `${qa?.result?.slice(0, 40)} | ${qb?.result?.slice(0, 40)}`) + check('……两行都收尾了,没有一直显示进行中', qa?.status === 'done' && qb?.status === 'done', `${qa?.status} ${qb?.status}`) + check('……检查结果挂在出问题的那条查询上', qa?.checks?.length === 1 && !qb?.checks, JSON.stringify(qb?.checks)) + const [c] = qa?.checks ?? [] + check('查询那一行带着 SQL 检查结果(级别、规则、表和列、关系编号),副标题数一下', c?.code === 'fanout_sum' && c.level === 'error' + && c.table === 'orders' && c.column === 'total_amount' && c.relation_id === 'r1a2b3c4d5e6' + && qa.sub === 'SQL 检查:1 处错误' && qa.level === 'warn', `${qa?.sub} ${qa?.level}`) + const rows = all.filter((s) => s.code === 'metric_sql_check') + check('同一条查询影响两个指标:时间线一行', rows.length === 1, String(rows.length)) + const m = rows[0] + check('……标题点名两个指标,副标题是问题', m?.title === '指标「订单金额」「客单价」所依据的查询未通过 SQL 检查' + && m.sub === synthetic.FANOUT_PROBLEM, `${m?.title} / ${m?.sub}`) + check('……「打开设置」指到来源查询节点的 SQL,不是口径卡', m?.fix === 'canvas' && m.fixNode === 'q_a' && m.fixField === 'args.sql' + && m.fixLabel === '订单金额查询' && m.nodeId === 'card', `${m?.fixNode} ${m?.fixField} ${m?.fixLabel}`) + check('……检查结果也挂在这一行,展开能看', m?.checks?.length === 1 && m.checks[0].code === 'fanout_sum') + check('……下一步说改来源查询的 SQL', !!m?.next?.includes('来源查询的 SQL'), m?.next) +}) + console.log(failed ? `\n✗ ${failed} 项未通过` : '\n✓ 解码器全部通过') process.exit(failed ? 1 : 0) diff --git a/scripts/check-stream.mjs b/scripts/check-stream.mjs index 843e6b1b..1ce628a2 100644 --- a/scripts/check-stream.mjs +++ b/scripts/check-stream.mjs @@ -735,6 +735,32 @@ await section('合并查询:输入、合并 SQL、结果预览,警告各占 await narrow.page.close() }) +await section('并行查询各配各的;查询的 SQL 检查;指标的问题指到来源查询的 SQL(A1、B2)', async () => { + const { page, errors } = await open('syn=parallel&link=1', { w: 1100, h: 900, name: 'parallel' }) + const qa = page.locator('[data-node-id="q_a"]').filter({ hasText: 'SQL 检查:1 处错误' }).last() + check('出问题的那条查询:行上就说「SQL 检查:1 处错误」', await qa.count() === 1) + await qa.locator('button').first().click() + await page.waitForTimeout(200) + const list = qa.locator('[data-step-sql-checks] [data-sql-check="fanout_sum"][data-level="error"]') + const text = (await qa.locator('[data-step-sql-checks]').innerText().catch(() => '')).replace(/\s+/g, ' ') + check('展开:用 SQL 检查清单列出级别、规则名、说明、涉及的表和列', await list.count() === 1 && text.includes('错误') + && text.includes('一对多关联后重复计算') && text.includes('orders.total_amount') && !text.includes('fanout_sum'), text) + const qb = (await page.locator('[data-node-id="q_b"]').last().innerText().catch(() => '')).replace(/\s+/g, ' ') + check('另一条查询没有检查结果,也没被配上别人的结果', !qb.includes('SQL 检查') && !qb.includes('119'), qb) + const metric = page.locator('[data-step-code="metric_sql_check"]') + check('两个指标出自同一条查询:时间线一行', await metric.count() === 1, String(await metric.count())) + const fix = metric.locator('[data-fix="canvas"]') + check('「打开设置」落到来源查询节点的 SQL:写「打开「订单金额查询」的 SQL」', (await fix.innerText().catch(() => '')).trim() + === '打开「订单金额查询」的 SQL' && await fix.getAttribute('data-fix-node') === 'q_a' + && await fix.getAttribute('data-fix-field') === 'args.sql', await fix.innerText().catch(() => '')) + await fix.click() + const opened = await page.evaluate(() => window.__opened ?? []) + check('……点了打开的是来源查询节点的 args.sql,不是口径卡', JSON.stringify(opened) === JSON.stringify([['q_a', 'args.sql']]), + JSON.stringify(opened)) + check('没有运行时报错', errors.length === 0, errors.join(' | ')) + await page.close() +}) + await section('参考了哪些表:画布右栏和问数据页(context 操作)', async () => { const c = await open('syn=copilot-context&dense=1', { w: 380, h: 800, name: 'copilot-context' }) const row = c.page.locator('[data-step-code="copilot_context"]')