cardbuddy 0.13.3 → 0.14.1

package/dist/vendored/skills/dsl-card-generator/scripts/lib/slice_pixels.mjs

@@ -0,0 +1,109 @@
+/**
+ * slice_pixels.mjs —— 切图「像素级内容判重」共享实现（slices_convention.md §3.1 根治配套）。
+ *
+ * 为什么 sha256 不够：同一张图可能有**两个像素相同但字节不同**的来源——
+ *  ① 设计稿导出资产（矢量渲染 PNG）；② 从 card-N.png / 画板整图**裁切**出来的派生图。
+ * 两者像素几乎一致但编码器/参数不同 → sha256 不同 → 仅靠 sha 的去重（slice_dedupe.mjs）
+ * 认不出「裁切图 ≡ 已存在的共用切图」，于是 src/slices 堆出 `_altN` / `__artboard_crop__` 重复副本
+ * （2026-09-18 ynet-card 事故：共用图标已重命名落地，仍被裁出 6 份重复副本）。
+ *
+ * 判重口径（权威 → 辅助）：
+ *  - **sha256（字节）**：一致即同图，最快路径；
+ *  - **像素容差比对**：尺寸相同 + 逐像素 RGBA 差 ≤ tol 的坏点占比 ≤ maxBadRatio → 同图
+ *    （容忍裁切/重编码带来的抗锯齿微差）；
+ *  - 文件名**不参与**判定（语义重命名后名字对不上是常态，见 manifest 别名）。
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { createHash } from 'node:crypto'
+
+const { PNG } = await import('pngjs')
+
+const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.webp'])
+
+/** 读 PNG；失败返回 null（非 PNG / 损坏 / 不存在）。 */
+export function readPng(file) {
+  try {
+    return PNG.sync.read(fs.readFileSync(file))
+  } catch {
+    return null
+  }
+}
+
+/** 从 src 裁出 [x,y,w,h)（像素坐标，已取整）返回新 PNG。 */
+export function cropPng(src, x, y, w, h) {
+  const cx = Math.max(0, Math.round(x))
+  const cy = Math.max(0, Math.round(y))
+  const cw = Math.max(1, Math.round(w))
+  const ch = Math.max(1, Math.round(h))
+  const out = new PNG({ width: cw, height: ch })
+  for (let py = 0; py < ch; py++) {
+    for (let px = 0; px < cw; px++) {
+      const si = ((cy + py) * src.width + (cx + px)) * 4
+      const di = (py * cw + px) * 4
+      for (let k = 0; k < 4; k++) out.data[di + k] = src.data[si + k] || 0
+    }
+  }
+  return out
+}
+
+/** PNG 像素缓冲的 sha256（含尺寸）：像素 identical 的裁切产物之间可快速判等。 */
+export function pngPixelSha(png) {
+  return createHash('sha256')
+    .update(`${png.width}x${png.height}:`)
+    .update(png.data)
+    .digest('hex')
+}
+
+/**
+ * 像素容差比对：尺寸必须一致；逐像素 RGBA 任一通道差 > tol 记一个坏点，
+ * 坏点占比 ≤ maxBadRatio 判同图（抗锯齿/重编码微差容忍）。
+ * @param {object} a PNG
+ * @param {object} b PNG
+ * @param {number} [tol=4] 单通道容差
+ * @param {number} [maxBadRatio=0.01] 坏点占比上限
+ */
+export function pixelsMatch(a, b, tol = 4, maxBadRatio = 0.01) {
+  if (!a || !b || a.width !== b.width || a.height !== b.height) return false
+  const total = a.width * a.height
+  if (!total) return false
+  let bad = 0
+  for (let i = 0; i < total * 4; i += 4) {
+    const dr = Math.abs(a.data[i] - b.data[i])
+    const dg = Math.abs(a.data[i + 1] - b.data[i + 1])
+    const db = Math.abs(a.data[i + 2] - b.data[i + 2])
+    const da = Math.abs(a.data[i + 3] - b.data[i + 3])
+    // 全透明像素的颜色无意义：双方都透明时不算坏点
+    if (a.data[i + 3] === 0 && b.data[i + 3] === 0) continue
+    if (dr > tol || dg > tol || db > tol || da > tol) {
+      bad++
+      if (bad / total > maxBadRatio) return false
+    }
+  }
+  return bad / total <= maxBadRatio
+}
+
+/**
+ * 在目录里找与目标 PNG **内容相同**的既有切图（sha 快路径 + 像素容差兜底）。
+ * 只扫扁平图片文件；`skip` 里的文件名排除（如自身 / 即将被覆盖的同名文件）。
+ * @param {string} dir 目标目录（如 src/slices）
+ * @param {object} png 目标 PNG（已解码）
+ * @param {{tol?:number, maxBadRatio?:number, skip?:string[]}} [opts]
+ * @returns {string|null} 命中返回扁平文件名，否则 null
+ */
+export function findPixelTwin(dir, png, opts = {}) {
+  if (!png || !dir || !fs.existsSync(dir)) return null
+  const skip = new Set(opts.skip || [])
+  const sha = pngPixelSha(png)
+  let fallback = null
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile() || skip.has(entry.name)) continue
+    if (!IMAGE_EXT.has(path.extname(entry.name).toLowerCase())) continue
+    const file = path.join(dir, entry.name)
+    const candidate = readPng(file)
+    if (!candidate || candidate.width !== png.width || candidate.height !== png.height) continue
+    if (pngPixelSha(candidate) === sha) return entry.name
+    if (!fallback && pixelsMatch(candidate, png, opts.tol, opts.maxBadRatio)) fallback = entry.name
+  }
+  return fallback
+}

package/dist/vendored/skills/dsl-card-generator/scripts/render_card.mjs

@@ -200,25 +200,63 @@ function createPreviewServer({ cardsRoot }) {
 /* ------------------------------------------------------------------ */
 /* Chrome + CDP 截屏                                                     */
 /* ------------------------------------------------------------------ */
-function findChromePath() {
-  const candidates = [
+/**
+ * 系统 Chromium 浏览器探测（跨平台）。
+ *
+ * Windows 上此前整条链路失效：候选是否按路径解析只认正斜杠（反斜杠的 CHROME_PATH 被
+ * 当成 PATH 命令名），命令查找又写死 which（Windows 无此命令，spawnSync 返回 status=null），
+ * 结果即使设了 CHROME_PATH 也报「未找到系统 Chrome」，训练轮全案例 renderFailures。
+ * 现按「显式路径 → 平台标准安装位置 → PATH 命令（where/which）」三段探测，
+ * 并以 Edge 作最后兜底（同为 Chromium/CDP，但字体度量可能与 Chrome 不同：
+ * 用它跑像素评分前须重跑 training/tools/probe_font_metrics.mjs 校准掩膜口径）。
+ */
+const IS_WINDOWS = process.platform === 'win32'
+
+/** 候选值应按文件系统路径（而非 PATH 命令名）解析吗？ */
+function looksLikeFsPath(value) {
+  return /[\\/]/.test(value) || /\.exe$/i.test(value)
+}
+
+/** PATH 命令查找：Windows 用 where，其余用 which；返回首个命中。 */
+function lookupInPath(command) {
+  const result = spawnSync(IS_WINDOWS ? 'where' : 'which', [command], { encoding: 'utf8' })
+  if (result.status !== 0 || !result.stdout) return null
+  const first = String(result.stdout).split(/\r?\n/).map((line) => line.trim()).filter(Boolean)[0]
+  return first || null
+}
+
+function chromeCandidates() {
+  const programFiles = process.env.ProgramFiles || 'C:\\Program Files'
+  const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)'
+  const localAppData = process.env.LOCALAPPDATA || ''
+  return [
     process.env.CHROME_PATH,
     process.platform === 'darwin' ? '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome' : null,
     process.platform === 'darwin' ? '/Applications/Chromium.app/Contents/MacOS/Chromium' : null,
+    IS_WINDOWS ? path.join(programFiles, 'Google', 'Chrome', 'Application', 'chrome.exe') : null,
+    IS_WINDOWS ? path.join(programFilesX86, 'Google', 'Chrome', 'Application', 'chrome.exe') : null,
+    IS_WINDOWS && localAppData ? path.join(localAppData, 'Google', 'Chrome', 'Application', 'chrome.exe') : null,
     'google-chrome',
     'google-chrome-stable',
     'chromium',
     'chromium-browser',
     'chrome',
+    // 兜底：Edge（Chromium 内核，CDP 兼容）
+    IS_WINDOWS ? path.join(programFilesX86, 'Microsoft', 'Edge', 'Application', 'msedge.exe') : null,
+    IS_WINDOWS ? path.join(programFiles, 'Microsoft', 'Edge', 'Application', 'msedge.exe') : null,
+    process.platform === 'darwin' ? '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge' : null,
+    'microsoft-edge',
   ].filter(Boolean)
+}
 
-  for (const c of candidates) {
-    if (c.includes('/')) {
-      if (fs.existsSync(c)) return c
+function findChromePath() {
+  for (const candidate of chromeCandidates()) {
+    if (looksLikeFsPath(candidate)) {
+      if (fs.existsSync(candidate)) return candidate
       continue
     }
-    const r = spawnSync('which', [c], { encoding: 'utf8' })
-    if (r.status === 0 && r.stdout.trim()) return r.stdout.trim()
+    const resolved = lookupInPath(candidate)
+    if (resolved) return resolved
   }
   return null
 }

package/dist/vendored/skills/dsl-card-generator/scripts/route_input.mjs

@@ -34,7 +34,7 @@ const SKETCH_SKILL = path.join(skillsDir, 'sketch-spec-to-card')
  * 作为提示文本随 next/note 下发，让判定器输出即带门禁，不依赖模型记住文档。
  */
 const SELECTION_GATE =
-  '# 多画板门禁（rules.md §十三）：把全量画板按 1..n 列出（序号 1 起）+ 末尾加「全部」；当前环境支持弹选项（request_user_input）就优先弹选择，否则一句提问后停止输出、等用户回序号再继续——UI 产物可回「全部」全量生成，产卡默认单画板 / 单 cardKey（回「全部」才算显式批量授权）；禁止自行挑画板、禁止擅自批量产卡；清单逐行配图：每个画板行下紧跟它自己的预览图绝对路径（--list / 门禁输出的 `图:` 行），与序号一一对应，缺图显式标缺失，禁止把图堆在清单末尾。'
+  '# 多画板门禁（rules.md §十三 + §13.4）：用 spec_tree.mjs --list-cards 把全量画板按「画板序号.卡片序号」列出（一个画板含 N 张卡则展开为 K.1 ~ K.N）+ 末尾加「全部」；让用户选的方式 = 正文逐条写清单 + 一句提问后停止输出、等用户回序号再继续（**没有** request_user_input 这个工具，不要去找弹窗，也不要替用户挑）；序号格式「画板序号.卡片序号」（如 1.2），单独回画板序号默认取该画板第 1 张卡；UI 产物可回「全部」全量生成，产卡默认单卡片（回「全部」才算显式批量授权）；禁止自行挑画板或挑卡、禁止擅自批量产卡；清单逐行配图：每个卡片行下紧跟它自己的 card-N.png 绝对路径，同一画板的卡共享画板预览图（artboard.png）但各有聚焦图；与序号一一对应，缺图显式标缺失，禁止把图堆在清单末尾。'
 /**
  * 要素包根目录 UI/：与上游 `sketch-spec-to-card/scripts/parse_meaxure.py` 的 `REPO_ROOT/UI`
  * （按脚本自身路径推算，非 cwd）保持同一锚点，避免「建议命令」与「实际落点」分叉。
@@ -330,12 +330,16 @@ function route(inputAbs) {
         },
         next: [
           specHint,
+          ...(bundle.artboardBundle ? [] : [
+            `# 先用 --list-cards 列出每个画板下的卡片清单（画板序号.卡片序号），交给用户选：`,
+            `node ${shortPath(path.join(skillsDir, 'dsl-card-generator', 'scripts', 'spec_tree.mjs'))} --list-cards ${shortPath(inputAbs)}`,
+            SELECTION_GATE,
+          ]),
           `# 再按 SKILL.md §8 Workflow A 六步闭环生成 schema（scaffold_card → add_component/expand_ir → validate+lint → render_diff）`,
-          ...(bundle.artboardBundle ? [] : [SELECTION_GATE]),
         ],
         note: bundle.artboardBundle
           ? '输入已是单画板要素包，无需前处理，直接走 Workflow A 生成本卡。'
-          : '输入已是 sketch-spec-to-card 的产物，无需前处理；多画板/多卡时先让用户指定单个画板或 cardKey（禁止自行挑、禁止擅自批量，rules.md §十三），再走 Workflow A；subcard 与 overlay_dialog 按 Workflow A.5 分流。',
+          : '输入已是 sketch-spec-to-card 的产物，无需前处理；多画板/多卡时先用 --list-cards 列出画板序号.卡片序号清单让用户选（禁止自行挑、禁止擅自批量，rules.md §十三 §13.4），再走 Workflow A；subcard 与 overlay_dialog 按 Workflow A.5 分流。',
       }
     }
 

package/dist/vendored/skills/dsl-card-generator/scripts/spec_audit.mjs

@@ -15,7 +15,10 @@
  * 输出（stdout JSON）：
  *   { card, design:{scale}, texts[], shapes[], slices[], bands[], gaps{}, colors[], missing[],
  *     bindHints[], listCandidates[] }
- *   - slices[].verdict ∈ full-asset / missing-file / reused-differs / reused-identical
+ *   - slices[].verdict ∈ full-asset / missing-file / reused-differs / reused-identical / content-twin
+ *     · content-twin：导出资产缺文件，但**既有切图里已有像素同内容**（共用/语义重命名/跨画板）→ 直接复用，不裁切
+ *     · crops[] 按**指纹分组**产出：同组（内容相同）的多个矩形共用一张派生图（alsoRects 列同组其余矩形），
+       不再「每个矩形一个 _altN」；派生前先对既有切图做像素级判重，命中给 reuseOf（引用改绑既有名，不裁切）
  *   - missing[] 给出建议裁剪矩形（配合 crop_slices.mjs 从聚焦截图派生缺失切图）
  *   - slices[].baked 说明切图里是否已含背景 / 标签文字（决定 tile 用单 Image 还是组合节点）
  *   - bindHints[] 是「变量候选」：金额 / 百分比 / 日期 / 掩码 / 数量这类一眼动态的文本，
@@ -26,6 +29,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 
 const { PNG } = await import('pngjs')
+import { cropPng, findPixelTwin } from './lib/slice_pixels.mjs'
 
 function parseArgs(argv) {
   const out = { spec: '', card: 1, slicesDir: '', design: '', projectSlices: '' }
@@ -53,7 +57,10 @@ function parseArgs(argv) {
 
 const hex = (r, g, b) => '#' + [r, g, b].map((v) => v.toString(16).padStart(2, '0')).join('').toUpperCase()
 const pxHex = (png, x, y) => {
-  const i = (y * png.width + x) * 4
+  // clamp 防越界：design 与 card.rect 比例非整倍 / 聚焦裁切带边距时，采样点可能出界 → undefined 崩溃
+  const cx = Math.min(png.width - 1, Math.max(0, Math.round(x)))
+  const cy = Math.min(png.height - 1, Math.max(0, Math.round(y)))
+  const i = (cy * png.width + cx) * 4
   return hex(png.data[i], png.data[i + 1], png.data[i + 2])
 }
 
@@ -97,12 +104,37 @@ function analyzeSlice(file) {
 }
 
 /** 切图名可能不带扩展名（spec 里存的是图层名），逐个候选扩展名找文件 */
-function resolveSliceFile(dirs, name) {
+/**
+ * manifest 别名表：语义重命名（slices_normalize / 手工改名）后，导出原名 → 新名的映射。
+ * 读各目录 manifest.json 的 renamedFrom / mergedFrom（§1.1「改名要成套做」的机器可读痕迹）。
+ */
+function buildAliasMap(dirs) {
+  const aliases = new Map()
+  for (const dir of dirs) {
+    const mf = path.join(dir, 'manifest.json')
+    if (!fs.existsSync(mf)) continue
+    let manifest = null
+    try { manifest = JSON.parse(fs.readFileSync(mf, 'utf8')) } catch { continue }
+    for (const [key, entry] of Object.entries((manifest && manifest.files) || {})) {
+      if (entry && typeof entry.renamedFrom === 'string') aliases.set(entry.renamedFrom, key)
+      for (const old of (entry && entry.mergedFrom) || []) if (typeof old === 'string') aliases.set(old, key)
+    }
+  }
+  return aliases
+}
+
+function resolveSliceFile(dirs, name, aliases = null) {
   const base = path.extname(name) ? name : `${name}.png`
+  const names = [name]
+  const alias = aliases && (aliases.get(name) || aliases.get(base))
+  if (alias) names.push(alias)
   for (const dir of dirs) {
-    for (const cand of [base, name, `${name}.jpg`, `${name}.jpeg`, `${name}.webp`]) {
-      const f = path.join(dir, cand)
-      if (fs.existsSync(f)) return f
+    for (const nm of names) {
+      const b = path.extname(nm) ? nm : `${nm}.png`
+      for (const cand of [b, nm, `${nm}.jpg`, `${nm}.jpeg`, `${nm}.webp`]) {
+        const f = path.join(dir, cand)
+        if (fs.existsSync(f)) return f
+      }
     }
   }
   return null
@@ -197,35 +229,89 @@ function main() {
   const slicesDir = args.slicesDir || path.join(path.dirname(args.spec), 'slices')
   // 派生切图的唯一落点是 src/slices/：已派生过的缺口不应再报 missing（否则每轮都建议重裁）
   const sliceDirs = [slicesDir, ...(args.projectSlices ? [args.projectSlices] : [])]
+  const aliases = buildAliasMap(sliceDirs)
   const missing = []
   const slices = []
+  /** 矩形按设计稿指纹分组：同组 = 内容相同（同一张图的多次复用），一组只派生一张图 */
+  const groupByFingerprint = (rects) => {
+    if (!design) return [{ idxs: rects.map((_, i) => i) }]
+    const groups = []
+    rects.forEach((r, i) => {
+      const fp = regionFingerprint(design, r, scale)
+      const g = groups.find((x) => x.fp === fp)
+      if (g) g.idxs.push(i)
+      else groups.push({ fp, idxs: [i] })
+    })
+    return groups
+  }
+  /** 设计稿矩形区域 ↔ 既有切图的像素级判重（sha 快路径 + 容差兜底，slice_pixels.mjs）。
+   *  覆盖「共用切图已语义重命名 / 在别的画板已派生过」——名字对不上也能认出来。 */
+  const regionTwin = (rect) => {
+    if (!design) return null
+    const region = cropPng(design, Math.round(rect.x * scale), Math.round(rect.y * scale), Math.round(rect.w * scale), Math.round(rect.h * scale))
+    for (const dir of sliceDirs) {
+      const twin = findPixelTwin(dir, region)
+      if (twin) return { twin, dir }
+    }
+    return null
+  }
   for (const [name, rects] of byName) {
-    const file = resolveSliceFile(sliceDirs, name)
-    const exists = !!file
-    const info = exists ? analyzeSlice(file) : null
+    let file = resolveSliceFile(sliceDirs, name, aliases)
+    let exists = !!file
+    let info = exists ? analyzeSlice(file) : null
     const logical = info ? [Math.round(info.px[0] / (info.px[0] / rects[0].w)), Math.round(info.px[1] / (info.px[1] / rects[0].h))] : null
     let verdict = exists ? 'full-asset' : 'missing-file'
+    let reuseOf = null
     let crops = null
+    const groups = groupByFingerprint(rects)
     if (!exists) {
-      const base0 = path.parse(name).name
-      crops = rects.map((r, i) => ({ name: i === 0 ? `${base0}.png` : `${base0}_alt${i + 1}.png`, ...r }))
-      missing.push({ reason: 'slice-file-missing', name, crop: crops[0] })
+      // 导出资产缺文件：先按指纹组对既有切图做像素级复用；整组命中 → 不裁切直接复用
+      const twin0 = regionTwin(rects[groups[0].idxs[0]])
+      if (twin0 && groups.length === 1) {
+        exists = true
+        verdict = 'content-twin'
+        reuseOf = twin0.twin
+        file = path.join(twin0.dir, twin0.twin)
+        info = analyzeSlice(file)
+      } else {
+        const base0 = path.parse(name).name
+        crops = []
+        groups.forEach((g, gi) => {
+          const rep = rects[g.idxs[0]]
+          const cn = gi === 0 ? `${base0}.png` : `${base0}_alt${gi + 1}.png`
+          const twin = gi === 0 ? twin0 : regionTwin(rep)
+          const entry = { name: cn, exists: !!resolveSliceFile(sliceDirs, cn, aliases), ...rep }
+          if (g.idxs.length > 1) entry.alsoRects = g.idxs.slice(1).map((i) => rects[i])
+          if (twin) { entry.exists = true; entry.reuseOf = twin.twin; entry.from = path.basename(twin.dir) }
+          crops.push(entry)
+          if (!entry.exists) missing.push({ reason: 'slice-file-missing', name, crop: entry })
+        })
+        if (twin0) { verdict = 'content-twin-partial'; reuseOf = twin0.twin }
+      }
     } else if (rects.length > 1 && design) {
-      const fps = rects.map((r) => regionFingerprint(design, r, scale))
-      const same = fps.every((f) => f === fps[0])
+      const same = groups.length === 1
       verdict = same ? 'reused-identical' : 'reused-differs'
       if (!same) {
-        // 同一张切图被标到内容不同的多个位置：除第一个外都要有独立派生图。
-        // crops 永远给全（带 exists 标记）——模型需要「矩形 → 该用哪张图」的映射；
-        // 历史事故：已派生过时 crops 被过滤成 []，模型拿不到映射就自造 icon_xx_左/右 这类
+        // 同一张切图被标到内容不同的多个位置：除第一组外每组一张派生图（组内矩形共用）。
+        // crops 永远给全（带 exists / reuseOf 标记）——模型需要「矩形 → 该用哪张图」的映射；
+        // 历史事故①：已派生过时 crops 被过滤成 []，模型拿不到映射就自造 icon_xx_左/右 这类
         // 违反命名约定的新切图，同一设计内容在 src/slices 下出现三套名字。
+        // 历史事故②（2026-09-18 ynet-card）：旧实现只跟 rects[0] 比指纹、每矩形一个 _altN，
+        // 内容相同的 5 个矩形裁出 5 份字节级重复副本；且不做既有切图判重，共用图标已重命名
+        // 落地仍被重裁。现按指纹分组 + 像素级复用根治。
         const baseN = path.parse(name).name
-        crops = rects.slice(1).map((r, i) => {
-          const cn = `${baseN}_alt${i + 2}.png`
-          return { name: cn, exists: !!resolveSliceFile(sliceDirs, cn), ...r }
-        })
-        for (const c of crops) {
-          if (!c.exists) missing.push({ reason: 'reused-slice-content-differs', name, crop: c })
+        crops = []
+        for (let gi = 1; gi < groups.length; gi++) {
+          const rep = rects[groups[gi].idxs[0]]
+          const cn = `${baseN}_alt${gi + 1}.png`
+          const entry = { name: cn, exists: !!resolveSliceFile(sliceDirs, cn, aliases), ...rep }
+          if (groups[gi].idxs.length > 1) entry.alsoRects = groups[gi].idxs.slice(1).map((i) => rects[i])
+          if (!entry.exists) {
+            const twin = regionTwin(rep)
+            if (twin) { entry.exists = true; entry.reuseOf = twin.twin; entry.from = path.basename(twin.dir) }
+          }
+          crops.push(entry)
+          if (!entry.exists) missing.push({ reason: 'reused-slice-content-differs', name, crop: entry })
         }
       }
     }
@@ -233,6 +319,7 @@ function main() {
       name,
       exists,
       from: file ? path.basename(path.dirname(file)) : null,
+      reuseOf,
       rects,
       px: info ? info.px : null,
       baked: info ? { bg: info.bg, label: info.label } : null,