cardbuddy 0.11.0 → 0.12.1

package/dist/vendored/skills/card-skill-trainer/scripts/build_sample.mjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * build_sample.mjs — 训练集视觉去重抽样
+ *
+ * 背景：设计稿画板存在大量近似重复（同一列表页的不同业务变体，布局/配色完全一致，
+ * 仅文案不同）。全量训练浪费算力且让指标被重复家族主导。
+ *
+ * 方法：
+ *  1. 对每个 case 的设计卡片图计算 dHash(64bit)：9x8 灰度网格水平梯度比较。
+ *  2. 贪心聚类：hamming 距离 <= threshold 视为同族（近似重复）。
+ *  3. 每族选"代表"：族内对其他成员总 hamming 距离最小者（中位代表），
+ *     并列时取 caseId 字典序最小者，保证结果可复现。
+ *  4. --force-include 指定的 caseId 强制保留（历史失败/探针案例，防回归漏盯）。
+ *
+ * 产物：
+ *  - train-set.sampled.jsonl   抽样后的训练集（迭代轮用）
+ *  - sampling-report.json      族划分详情（哪些画板被折叠、代表是谁）
+ *
+ * 全量 train-set.jsonl 保留不动，里程碑验收轮仍用全量。
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { PNG } from 'pngjs'
+
+function parseArgs() {
+  const args = process.argv.slice(2)
+  const opt = { dataset: null, out: null, report: null, threshold: 6, forceInclude: [] }
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--dataset') opt.dataset = args[++i]
+    else if (args[i] === '--out') opt.out = args[++i]
+    else if (args[i] === '--report') opt.report = args[++i]
+    else if (args[i] === '--threshold') opt.threshold = Number(args[++i])
+    else if (args[i] === '--force-include') opt.forceInclude = args[++i].split(',').filter(Boolean)
+  }
+  if (!opt.dataset) { console.error('usage: build_sample.mjs --dataset <jsonl> [--out p] [--report p] [--threshold 6] [--force-include id1,id2]'); process.exit(1) }
+  if (!opt.out) opt.out = opt.dataset.replace(/\.jsonl$/, '.sampled.jsonl')
+  if (!opt.report) opt.report = opt.dataset.replace(/\.jsonl$/, '.sampling-report.json')
+  return opt
+}
+
+/** dHash: 采样到 9x8 灰度网格，相邻像素比较产生 64bit hash（BigInt 低位=bit0） */
+function dhash64(png) {
+  const gw = 9, gh = 8
+  const gray = new Float64Array(gw * gh)
+  for (let gy = 0; gy < gh; gy++) {
+    for (let gx = 0; gx < gw; gx++) {
+      // 盒式采样：目标格对应的源区域取均值，避免单点采样对噪点敏感
+      const x0 = Math.floor(gx * png.width / gw), x1 = Math.max(x0 + 1, Math.floor((gx + 1) * png.width / gw))
+      const y0 = Math.floor(gy * png.height / gh), y1 = Math.max(y0 + 1, Math.floor((gy + 1) * png.height / gh))
+      let sum = 0, cnt = 0
+      for (let y = y0; y < y1; y += Math.max(1, Math.floor((y1 - y0) / 4))) {
+        for (let x = x0; x < x1; x += Math.max(1, Math.floor((x1 - x0) / 4))) {
+          const idx = (y * png.width + x) * 4
+          sum += 0.299 * png.data[idx] + 0.587 * png.data[idx + 1] + 0.114 * png.data[idx + 2]
+          cnt++
+        }
+      }
+      gray[gy * gw + gx] = sum / cnt
+    }
+  }
+  let h = 0n
+  for (let gy = 0; gy < gh; gy++) {
+    for (let gx = 0; gx < gw - 1; gx++) {
+      if (gray[gy * gw + gx] > gray[gy * gw + gx + 1]) h |= (1n << BigInt(gy * (gw - 1) + gx))
+    }
+  }
+  return h
+}
+
+function hamming(a, b) {
+  let x = a ^ b, n = 0
+  while (x) { n += Number(x & 1n); x >>= 1n }
+  return n
+}
+
+const opt = parseArgs()
+// 防御性按 caseId 去重：历史数据集（v4 实测 221 行 / 218 唯一）由重复发现的同名源目录
+// 产出过逐字节相同的 case，会让代表集重复计入同一张卡、passRate 分母失真。
+// build_dataset.py 已在源头去重，这里对既有数据集兜底。
+const cases = (() => {
+  const seen = new Set()
+  const dropped = []
+  const rows = fs.readFileSync(opt.dataset, 'utf8').trim().split('\n').map(l => JSON.parse(l))
+    .filter((row) => {
+      if (seen.has(row.caseId)) { dropped.push(row.caseId); return false }
+      seen.add(row.caseId)
+      return true
+    })
+  if (dropped.length) console.log(`[sample] 去重 ${dropped.length} 条重复 caseId：${[...new Set(dropped)].join(', ')}`)
+  return rows
+})()
+
+// 1) 计算每个 case 的 dHash
+const entries = []
+for (const c of cases) {
+  const img = c.input?.designImage
+  if (!img || !fs.existsSync(img)) { entries.push({ c, hash: null }); continue }
+  entries.push({ c, hash: dhash64(PNG.sync.read(fs.readFileSync(img))) })
+}
+
+// 2) 贪心聚类（按 caseId 排序保证可复现）
+entries.sort((a, b) => a.c.caseId.localeCompare(b.c.caseId))
+const clusters = [] // {rep hash, members:[entry]}
+for (const e of entries) {
+  if (e.hash === null) { clusters.push({ members: [e] }); continue }
+  let hit = null
+  for (const cl of clusters) {
+    const ref = cl.members[0].hash
+    if (ref !== null && hamming(e.hash, ref) <= opt.threshold) { hit = cl; break }
+  }
+  if (hit) hit.members.push(e); else clusters.push({ members: [e] })
+}
+
+// 3) 族内代表 = 总距离最小者
+const picked = new Map() // caseId -> cluster info
+const reportClusters = []
+for (const cl of clusters) {
+  let best = cl.members[0], bestSum = Infinity
+  for (const m of cl.members) {
+    let sum = 0
+    for (const o of cl.members) { if (o !== m && m.hash !== null && o.hash !== null) sum += hamming(m.hash, o.hash) }
+    if (sum < bestSum || (sum === bestSum && m.c.caseId < best.c.caseId)) { best = m; bestSum = sum }
+  }
+  picked.set(best.c.caseId, true)
+  reportClusters.push({
+    representative: best.c.caseId,
+    artboard: best.c.artboardName,
+    source: best.c.source,
+    size: cl.members.length,
+    folded: cl.members.filter(m => m !== best).map(m => m.c.caseId),
+  })
+}
+
+// 4) 强制保留
+for (const id of opt.forceInclude) {
+  const e = entries.find(x => x.c.caseId === id)
+  if (e) picked.set(id, true)
+}
+
+const sampled = entries.filter(e => picked.has(e.c.caseId)).map(e => e.c)
+fs.writeFileSync(opt.out, sampled.map(c => JSON.stringify(c)).join('\n') + '\n')
+
+// 报告按 source 汇总
+const bySource = {}
+for (const cl of reportClusters) {
+  bySource[cl.source] = bySource[cl.source] || { clusters: 0, foldedCases: 0, keptCases: 0 }
+  bySource[cl.source].clusters++
+  bySource[cl.source].foldedCases += cl.size - 1
+  bySource[cl.source].keptCases += 1
+}
+fs.writeFileSync(opt.report, JSON.stringify({
+  dataset: opt.dataset,
+  threshold: opt.threshold,
+  totalCases: cases.length,
+  sampledCases: sampled.length,
+  forceIncluded: opt.forceInclude,
+  bySource,
+  clusters: reportClusters.sort((a, b) => b.size - a.size),
+}, null, 2))
+
+console.log(`total=${cases.length} sampled=${sampled.length} clusters=${clusters.length} (threshold=${opt.threshold})`)
+for (const [s, v] of Object.entries(bySource)) console.log(`  ${s}: kept=${v.keptCases} folded=${v.foldedCases}`)

package/dist/vendored/skills/card-skill-trainer/scripts/diagnose_case.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/**
+ * diagnose_case.mjs — 失败案例一键诊断证据包
+ *
+ * 把「肉眼并排 → 像素分带 → 标注几何 vs 渲染盒 → schema 溯源」这条手工诊断
+ * 链路产品化为单条命令。输出全部落在该轮 reports/ 目录（训练产物，不入 src）：
+ *   <caseId>.side.png   设计稿|渲染 并排图（红色分隔线）
+ *   终端打印            像素分带直方图、偏差元素表（dy/dx）、生成器源码行溯源、
+ *                       校正器干预记录、失败类建议
+ *
+ * 用法：
+ *   node skills/card-skill-trainer/scripts/diagnose_case.mjs --run training/runs/r171 --case <caseId>
+ *   [--dataset training/datasets/v4/train-set.sampled.jsonl]  (缺省自动扫描 datasets)
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { PNG } from 'pngjs'
+
+const repoRoot = path.resolve(import.meta.dirname, '../../..')
+
+function parseArgs(argv) {
+  const out = { run: '', case: '', dataset: '' }
+  for (let index = 0; index < argv.length; index += 2) {
+    const key = argv[index].replace(/^--/, '')
+    out[key] = argv[index + 1]
+  }
+  return out
+}
+const args = parseArgs(process.argv.slice(2))
+if (!args.run || !args.case) {
+  console.error('usage: diagnose_case.mjs --run <roundDir> --case <caseId> [--dataset <jsonl>]')
+  process.exit(1)
+}
+const runDir = path.resolve(args.run)
+const reportDir = path.join(runDir, 'reports')
+const report = JSON.parse(fs.readFileSync(path.join(reportDir, `${args.case}.json`), 'utf8'))
+
+// —— 数据集条目定位（spec 路径 + cardIndex）——
+function findDatasetEntry() {
+  const candidates = args.dataset
+    ? [path.resolve(args.dataset)]
+    : (() => {
+        const rootDir = path.join(repoRoot, 'training/datasets')
+        const files = []
+        for (const ver of fs.readdirSync(rootDir)) {
+          const dir = path.join(rootDir, ver)
+          if (!fs.statSync(dir).isDirectory()) continue
+          for (const f of fs.readdirSync(dir)) {
+            if (f.endsWith('.jsonl')) files.push(path.join(dir, f))
+          }
+        }
+        return files
+      })()
+  for (const file of candidates) {
+    const lines = fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean)
+    for (const line of lines) {
+      const item = JSON.parse(line)
+      if (item.caseId === args.case) return { entry: item, datasetFile: file }
+    }
+  }
+  throw new Error(`caseId ${args.case} not found in ${args.dataset || 'training/datasets/*'}`)
+}
+const { entry } = findDatasetEntry()
+const spec = JSON.parse(fs.readFileSync(entry.input.specJson, 'utf8'))
+const cardMeta = (spec.cards || [])[entry.cardIndex ?? 0] || (spec.cards || [])[0]
+const cardRect = cardMeta?.rect || { x: 0, y: 0, width: 343, height: 200 }
+
+// —— 1. 并排图（持久化到 reports/）——
+const designPng = PNG.sync.read(fs.readFileSync(path.join(reportDir, `${args.case}.design.png`)))
+const renderPng = PNG.sync.read(fs.readFileSync(path.join(reportDir, `${args.case}.render.png`)))
+const sideW = designPng.width + renderPng.width + 8
+const sideH = Math.max(designPng.height, renderPng.height)
+const side = new PNG({ width: sideW, height: sideH, colorType: 2 })
+for (let y = 0; y < sideH; y++) {
+  for (let x = 0; x < sideW; x++) {
+    const di = (y * sideW + x) * 4
+    side.data[di] = 255; side.data[di + 1] = 0; side.data[di + 2] = 0; side.data[di + 3] = 255
+  }
+}
+const blit = (src, xOff) => {
+  for (let y = 0; y < src.height; y++) {
+    for (let x = 0; x < src.width; x++) {
+      const si = (y * src.width + x) * 4
+      const di = (y * sideW + x + xOff) * 4
+      side.data[di] = src.data[si]; side.data[di + 1] = src.data[si + 1]
+      side.data[di + 2] = src.data[si + 2]; side.data[di + 3] = 255
+    }
+  }
+}
+blit(designPng, 0); blit(renderPng, designPng.width + 8)
+const sidePath = path.join(reportDir, `${args.case}.side.png`)
+fs.writeFileSync(sidePath, PNG.sync.write(side))
+
+// —— 2. 像素分带直方图（含豁免区掩码）——
+const w = Math.min(designPng.width, renderPng.width)
+const h = Math.min(designPng.height, renderPng.height)
+const mask = new Uint8Array(w * h)
+for (const rc of report.pixelExclusions || []) {
+  const x0 = Math.floor((rc.x ?? 0) * w), y0 = Math.floor((rc.y ?? 0) * h)
+  const x1 = Math.min(w, Math.ceil(((rc.x ?? 0) + (rc.width ?? 0)) * w))
+  const y1 = Math.min(h, Math.ceil(((rc.y ?? 0) + (rc.height ?? 0)) * h))
+  for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) mask[y * w + x] = 1
+}
+const BANDS = 20
+const bandDiff = new Array(BANDS).fill(0)
+const bandTotal = new Array(BANDS).fill(0)
+let totalDiff = 0
+let totalCount = 0
+for (let y = 0; y < h; y++) {
+  const band = Math.min(BANDS - 1, Math.floor((y / h) * BANDS))
+  for (let x = 0; x < w; x++) {
+    if (mask[y * w + x]) continue
+    const i = (y * designPng.width + x) * 4
+    const j = (y * renderPng.width + x) * 4
+    const diff = Math.abs(designPng.data[i] - renderPng.data[j]) > 15
+      || Math.abs(designPng.data[i + 1] - renderPng.data[j + 1]) > 15
+      || Math.abs(designPng.data[i + 2] - renderPng.data[j + 2]) > 15
+    if (diff) { bandDiff[band]++; totalDiff++ }
+    bandTotal[band]++; totalCount++
+  }
+}
+const bandPct = bandDiff.map((c, i) => (bandTotal[i] ? c / bandTotal[i] : 0))
+const hotBands = bandPct.map((p2, i) => ({ band: i, y: Math.round((i / BANDS) * h), pct: p2 }))
+  .filter((b) => b.pct >= 0.05).sort((a, b) => b.pct - a.pct)
+
+// —— 3. 标注几何 vs 渲染盒（文本元素，按 |dy| 排序）——
+process.env.DSL_CARD_CARDS_DIR = path.join(runDir, 'cards')
+process.env.DSL_CARD_SLICES_DIR = path.join(runDir, 'slices')
+const { createRenderSession } = await import(repoRoot + '/skills/dsl-card-generator/scripts/render_card.mjs')
+const session = await createRenderSession({ cardsRoot: path.join(runDir, 'cards') })
+const scaleX = designPng.width / (cardRect.width || 343)
+const cardId = report.cardId || `${path.basename(runDir)}__${args.case}`
+const rendered = await session.render({ id: cardId, width: cardRect.width || 343, captureHeight: Math.ceil(h / scaleX), format: 'png', captureElements: true })
+await session.close()
+if (!rendered.ok) { console.error('re-render failed:', rendered.error); process.exit(1) }
+const renderTexts = (rendered.elementBoxes || [])
+  .filter((b) => b.text && ['Text', 'Input', 'Button'].includes(b.cls))
+const specTexts = (spec.elements || [])
+  .filter((el) => el.type === 'text' && (el.text || '').trim())
+  .map((el) => ({
+    text: String(el.text).trim().replace(/\s+/g, ''),
+    x: (el.rect?.x || 0) - (cardRect.x || 0),
+    y: (el.rect?.y || 0) - (cardRect.y || 0),
+    w: el.rect?.width || 0,
+    h: el.rect?.height || 0,
+    fs: el.textStyle?.fontSize || 14,
+    lineHeight: el.textStyle?.lineHeight ?? null,
+  }))
+const norm = (s) => String(s || '').replace(/\s+/g, '')
+const usedSpec = new Set()
+const deviations = []
+for (const rt of renderTexts) {
+  const key = norm(rt.text)
+  if (!key) continue
+  let best = null
+  let bestScore = 0
+  for (let i = 0; i < specTexts.length; i++) {
+    if (usedSpec.has(i)) continue
+    const st = specTexts[i]
+    let score = 0
+    if (st.text === key) score = 1
+    else if (st.text.includes(key) || key.includes(st.text)) score = 0.9
+    if (score > bestScore) { bestScore = score; best = { ...st, idx: i } }
+  }
+  if (!best || bestScore < 0.9) continue
+  usedSpec.add(best.idx)
+  deviations.push({
+    text: key.slice(0, 18),
+    dy: +(rt.y - best.y).toFixed(1),
+    dx: +(rt.x - best.x).toFixed(1),
+    dw: +((rt.w || 0) - best.w).toFixed(1),
+    dh: +((rt.h || 0) - best.h).toFixed(1),
+    render: { x: rt.x, y: rt.y, w: rt.w, h: rt.h },
+    spec: { x: best.x, y: best.y, w: best.w, h: best.h, fs: best.fs, lineHeight: best.lineHeight },
+    cid: rt.cid,
+  })
+}
+deviations.sort((a, b) => (Math.abs(b.dy) + Math.abs(b.dx)) - (Math.abs(a.dy) + Math.abs(a.dx)))
+
+// —— 4. 生成器源码行溯源（SCHEMA_PROV 重生成，仅偏差 TopN）——
+let provHits = []
+try {
+  process.env.SCHEMA_PROV = '1'
+  const { generate } = await import(repoRoot + '/skills/dsl-card-generator/scripts/spec_to_schema_v3.mjs')
+  const out = generate(spec, { id: 'diagnose', name: 'diagnose', cardIndex: entry.cardIndex ?? 0, designImage: entry.input.designImage })
+  const provByCid = new Map()
+  const textByCid = new Map()
+  const walkProv = (node) => {
+    if (!node) return
+    if (node.componentId) {
+      if (node.__prov) provByCid.set(node.componentId, node.__prov)
+      const prop = (node.properties || []).find((pp) => pp.itemKey === 'value')
+      const val = norm(prop?.itemDefaultValue || prop?.itemValue)
+      if (val && !textByCid.has(node.componentId)) textByCid.set(node.componentId, val)
+    }
+    for (const c of node.components || []) walkProv(c)
+    for (const sl of node.slots || []) for (const c of sl.components || []) walkProv(c)
+  }
+  walkProv(out.schema.view)
+  const topCids = [...new Set(deviations.slice(0, 6).map((d) => d.cid).filter(Boolean))]
+  provHits = topCids.map((cid) => ({ cid, prov: provByCid.get(cid) || '(未登记/由组装层创建)', text: (textByCid.get(cid) || '').slice(0, 18) }))
+} catch (e) {
+  provHits = [{ error: String(e.message || e) }]
+}
+
+// —— 5. 汇总输出 ——
+const px = report.pixel || {}
+const fid = report.fidelity || {}
+console.log('═══════════════════════════════════════════════════════════')
+console.log(`诊断 ${args.case} | ${report.artboardName || ''}`)
+console.log(`side-by-side: ${path.relative(repoRoot, sidePath)}`)
+console.log(`passed=${report.passed}  pix=${px.ratio?.toFixed(4)} struct=${px.structure?.toFixed(4)} dy=${px.bestAlignDy} fid=${fid.overall?.toFixed(4)} pos=${fid.position?.toFixed(4)} comp=${fid.components?.toFixed(4)}`)
+if (report.layoutCorrections?.length) {
+  console.log(`校正器干预 ${report.layoutCorrections.length} 处（守卫通过）:`, JSON.stringify(report.layoutCorrections.slice(0, 5)))
+}
+if (report.correctorRejected) {
+  console.log(`校正器干预被守卫拒绝（${report.correctorRejected.reason}）:`, JSON.stringify(report.correctorRejected.adjustments?.slice(0, 5) || []))
+}
+console.log('── 像素热区 (band≥5%) ──')
+for (const b of hotBands) {
+  console.log(`  y≈${String(b.y).padStart(4)}  ${(b.pct * 100).toFixed(1)}%  ${'#'.repeat(Math.round(b.pct * 50))}`)
+}
+console.log('── 元素偏差 Top10 (|dy|+|dx| 降序, pt@343宽) ──')
+for (const d of deviations.slice(0, 10)) {
+  console.log(`  dy=${String(d.dy).padStart(5)} dx=${String(d.dx).padStart(5)} dw=${String(d.dw).padStart(5)} dh=${String(d.dh).padStart(5)}  '${d.text}'  spec[y=${d.spec.y} h=${d.spec.h} fs=${d.spec.fs} lh=${d.spec.lineHeight ?? '-'}] render[y=${d.render.y} h=${d.render.h}]`)
+}
+console.log('── 偏差节点 → 生成器源码行 ──')
+for (const phit of provHits) {
+  if (phit.error) { console.log('  溯源失败:', phit.error); continue }
+  console.log(`  ${phit.cid} '${phit.text}' → ${phit.prov}`)
+}
+console.log('── 失败类建议 ──')
+const hints = []
+if (px.bestAlignDy && Math.abs(px.bestAlignDy) >= 4) hints.push(`全局纵向偏移 dy=${px.bestAlignDy}：查行高/行距累积（Input 高度、行距标注优先、分割线渲染盒高）`)
+if (hotBands.length && hotBands[0].pct >= 0.2) hints.push(`单带高热 (${(hotBands[0].pct * 100).toFixed(0)}%@y≈${hotBands[0].y})：查该区域语义块（换行折点/缺组件/结构错配）`)
+if ((fid.components ?? 1) < 0.9) hints.push(`组件计数缺失 comp=${fid.components?.toFixed(2)}：查语义消费（媒体未渲染/文本被吞/重复消费）`)
+if ((report.duplication?.overall ?? 1) < 0.95) hints.push('重影：查同源按钮/文本双路径渲染')
+const bigDy = deviations.filter((d) => Math.abs(d.dy) >= 3)
+if (bigDy.length >= 3) hints.push(`${bigDy.length} 个文本 |dy|≥3：纵向节奏问题（行距/padding 体系），非单点`)
+if (!hints.length) hints.push('像素差异弥散且量级低：多为 1-2px 抗锯齿/字体度量差异，接近噪声底')
+for (const hint of hints) console.log('  •', hint)