cardbuddy 0.11.0 → 0.12.1

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

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+/**
+ * route_input.mjs — 建卡输入形态路由（SKILL.md §8 Workflow 0 的机械判定器）。
+ *
+ * 收到建卡请求先把用户给的输入路径喂给本工具，由它判定形态并给出下一步命令，
+ * 避免 AI 凭感觉决定「要不要先跑 sketch-spec-to-card」：
+ *   node scripts/route_input.mjs ~/Downloads/转账ui设计稿0723
+ *   node scripts/route_input.mjs UI/01基金_基金推荐 --json
+ *
+ * 判定结果（kind）：
+ *   meaxure-export  Sketch MeaXure 标注导出目录（index.html 内嵌 artboards + preview/ + assets/）
+ *                   → 必须先经 sketch-spec-to-card 前处理，禁止直接拿 preview/ 整图建卡；
+ *                     若 UI/ 下已有 export 匹配的 manifest.json 则跳过前处理，直接消费存量产物。
+ *   ui-bundle       sketch-spec-to-card 的产物（manifest.json / spec.json + card-N.png）→ Workflow A 按用户指定的单画板生成
+ *   card-dir        已存在的卡片目录（schema.json）→ Workflow B 编辑
+ *   image           单张截图/设计稿 PNG → Workflow A（无 spec，全靠视觉推断）
+ *   unknown         判不出形态，需人工确认输入
+ *
+ * 退出码：0 = 已路由；3 = unknown（需人工确认）；1 = 用法错误 / 路径不存在。
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { skillsDir } from './lib/paths.mjs'
+
+const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.webp'])
+/** 已知入口文件：判定交给它所在目录（index.html=MeaXure 导出；manifest/clusters/spec/prompt=要素包；schema=卡片目录）。 */
+const ENTRY_FILES = new Set(['index.html', 'manifest.json', 'clusters.json', 'spec.json', 'spec.md', 'prompt.md', 'schema.json'])
+const SKETCH_SKILL = path.join(skillsDir, 'sketch-spec-to-card')
+/**
+ * 多画板选择门禁（铁律见 references/rules.md §十三）：UI 产物允许全量生成，
+ * 但卡片生成必须以用户指定的单个画板 / 单个 cardKey 为单位。
+ * 作为提示文本随 next/note 下发，让判定器输出即带门禁，不依赖模型记住文档。
+ */
+const SELECTION_GATE =
+  '# 多画板门禁（rules.md §十三）：把全量画板按 1..n 列出（序号 1 起）+ 末尾加「全部」；当前环境支持弹选项（request_user_input）就优先弹选择，否则一句提问后停止输出、等用户回序号再继续——UI 产物可回「全部」全量生成，产卡默认单画板 / 单 cardKey（回「全部」才算显式批量授权）；禁止自行挑画板、禁止擅自批量产卡；清单逐行配图：每个画板行下紧跟它自己的预览图绝对路径（--list / 门禁输出的 `图:` 行），与序号一一对应，缺图显式标缺失，禁止把图堆在清单末尾。'
+/**
+ * 要素包根目录 UI/：与上游 `sketch-spec-to-card/scripts/parse_meaxure.py` 的 `REPO_ROOT/UI`
+ * （按脚本自身路径推算，非 cwd）保持同一锚点，避免「建议命令」与「实际落点」分叉。
+ * 可用 DSL_CARD_UI_DIR 直接指定，或用 DSL_CARD_PROJECT_ROOT 指定宿主工程根。
+ */
+const REPO_ROOT = path.resolve(skillsDir, '..')
+const UI_ROOT =
+  process.env.DSL_CARD_UI_DIR || path.join(process.env.DSL_CARD_PROJECT_ROOT || REPO_ROOT, 'UI')
+
+function exists(target) {
+  try {
+    fs.accessSync(target)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function isDir(target) {
+  try {
+    return fs.statSync(target).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function entries(target) {
+  try {
+    return fs.readdirSync(target, { withFileTypes: true })
+  } catch {
+    return []
+  }
+}
+
+/** 大文件安全读取：超过 cap 时只取头尾各一半（MeaXure 的 data 通常在 index.html 尾部）。 */
+function readTextCapped(file, cap = 64 * 1024 * 1024) {
+  const size = fs.statSync(file).size
+  if (size <= cap) return fs.readFileSync(file, 'utf8')
+  const half = Math.floor(cap / 2)
+  const fd = fs.openSync(file, 'r')
+  const head = Buffer.alloc(half)
+  const tail = Buffer.alloc(half)
+  fs.readSync(fd, head, 0, half, 0)
+  fs.readSync(fd, tail, 0, half, Math.max(0, size - half))
+  fs.closeSync(fd)
+  return head.toString('utf8') + tail.toString('utf8')
+}
+
+/** 命令里输出相对 cwd 的短路径，跨盘/越界时退回绝对路径。 */
+function shortPath(abs) {
+  const rel = path.relative(process.cwd(), abs)
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? rel : abs
+}
+
+function pythonBin() {
+  if (process.env.DSL_CARD_PYTHON) return process.env.DSL_CARD_PYTHON
+  for (const bin of ['python3', 'python']) {
+    const probe = spawnSync(bin, ['--version'], { stdio: 'ignore' })
+    if (probe.status === 0) return bin
+  }
+  return 'python3'
+}
+
+/** Sketch MeaXure 标注导出判定：index.html 的 data 签名是硬证据，preview/ assets/ links/ 是佐证。 */
+function detectMeaxure(dir) {
+  const evidence = []
+  const indexHtml = path.join(dir, 'index.html')
+  let signature = false
+  if (exists(indexHtml)) {
+    try {
+      const text = readTextCapped(indexHtml)
+      signature = /let\s+data\s*=/.test(text) && /"artboards"\s*:/.test(text)
+      if (signature) evidence.push('index.html 内嵌 let data = {"artboards":[...]} 标注 JSON')
+      else evidence.push('index.html 存在但未命中 MeaXure data 签名')
+    } catch {
+      evidence.push('index.html 不可读')
+    }
+  }
+  const previewDir = path.join(dir, 'preview')
+  const assetsDir = path.join(dir, 'assets')
+  const linksDir = path.join(dir, 'links')
+  const previewPngs = isDir(previewDir)
+    ? entries(previewDir).filter((e) => e.isFile() && IMAGE_EXT.has(path.extname(e.name).toLowerCase())).length
+    : 0
+  if (previewPngs) evidence.push(`preview/ 画板整图 ${previewPngs} 张`)
+  if (isDir(assetsDir)) evidence.push('assets/ 切图素材目录')
+  if (isDir(linksDir)) evidence.push('links/ 重定向页（MeaXure 附带）')
+
+  const matched = signature || (exists(indexHtml) && (previewPngs > 0 || isDir(assetsDir)))
+  return { matched, confidence: signature ? 'high' : 'medium', evidence, previewPngs }
+}
+
+/** sketch-spec-to-card 产物判定：支持平铺（UI/<画板>/）与按稿分片（UI/<稿名>/<画板>/）两种布局。 */
+function detectUiBundle(dir) {
+  const evidence = []
+  const manifest = path.join(dir, 'manifest.json')
+  const clusters = path.join(dir, 'clusters.json')
+  const ownSpec = path.join(dir, 'spec.json')
+  const ownCards = entries(dir).filter((e) => e.isFile() && /^card-\d+\.png$/i.test(e.name)).length
+
+  if (exists(manifest)) evidence.push('manifest.json 画板清单')
+  if (exists(clusters)) evidence.push('clusters.json 聚类/状态模型')
+  if (exists(ownSpec)) evidence.push('spec.json 视觉要素标注')
+  if (ownCards) evidence.push(`card-N.png 聚焦图 ${ownCards} 张`)
+
+  const subBoards = entries(dir)
+    .filter((e) => e.isDirectory())
+    .map((e) => path.join(dir, e.name))
+    .filter((sub) => exists(path.join(sub, 'spec.json')))
+  if (subBoards.length) evidence.push(`${subBoards.length} 个画板子目录含 spec.json`)
+
+  const isArtboardBundle = exists(ownSpec) && ownCards > 0
+  const matched = exists(manifest) || isArtboardBundle || subBoards.length > 0
+  return {
+    matched,
+    confidence: exists(manifest) || isArtboardBundle ? 'high' : 'medium',
+    evidence,
+    manifest: exists(manifest) ? manifest : null,
+    clusters: exists(clusters) ? clusters : null,
+    artboardBundle: isArtboardBundle,
+    specJson: exists(ownSpec) ? ownSpec : null,
+    cardImages: ownCards,
+    boards: subBoards,
+  }
+}
+
+/** 统计一份 manifest 里「已产出要素包」的画板数：同一导出有多套产物时用它挑主产物。 */
+function countGenerated(manifest) {
+  const canvases = Array.isArray(manifest?.canvases) ? manifest.canvases : []
+  return {
+    generated: canvases.filter((c) => c && c.status === 'generated').length,
+    total: canvases.length,
+  }
+}
+
+/**
+ * 在 UI/ 下找已前处理过的产物：比对 manifest.export 与输入目录，其次按稿名兜底。
+ *
+ * 同一份导出可能同时存在两套产物（历史上先平铺跑过 UI/<画板>/，后来改用按稿分片 UI/<稿名>/<画板>/）：
+ * 只返回第一份会让下游误判「目标画板还没前处理」而重跑管线，故这里收集全部匹配，
+ * 以「已生成画板最多」的为主产物，其余进 alsoFound 一并报告。
+ */
+function findPreprocessed(srcAbs) {
+  const norm = (p) => path.resolve(String(p || '')).replace(/[\\/]+$/, '')
+  const target = norm(srcAbs)
+  const candidates = [UI_ROOT, ...entries(UI_ROOT).filter((e) => e.isDirectory()).map((e) => path.join(UI_ROOT, e.name))]
+  const matches = []
+  for (const root of candidates) {
+    const manifestPath = path.join(root, 'manifest.json')
+    if (!exists(manifestPath)) continue
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+      if (manifest.export && norm(manifest.export) === target) {
+        matches.push({
+          uiDir: root,
+          manifest: manifestPath,
+          draft: manifest.draft || null,
+          via: 'manifest.export 匹配',
+          ...countGenerated(manifest),
+        })
+      }
+    } catch {
+      // 坏 manifest 不作为证据，继续找下一个
+    }
+  }
+  if (!matches.length) {
+    const byName = path.join(UI_ROOT, path.basename(target), 'manifest.json')
+    if (exists(byName)) {
+      let counts = { generated: 0, total: 0 }
+      try {
+        counts = countGenerated(JSON.parse(fs.readFileSync(byName, 'utf8')))
+      } catch {
+        /* 坏 manifest 仍按目录名匹配，只是不带统计 */
+      }
+      return {
+        uiDir: path.dirname(byName),
+        manifest: byName,
+        draft: path.basename(target),
+        via: '稿名同名目录兜底匹配',
+        ...counts,
+        alsoFound: [],
+      }
+    }
+    return null
+  }
+  matches.sort((a, b) => b.generated - a.generated || a.uiDir.length - b.uiDir.length)
+  const [best, ...rest] = matches
+  return {
+    ...best,
+    alsoFound: rest.map((m) => ({ uiDir: shortPath(m.uiDir), manifest: shortPath(m.manifest), generated: m.generated, total: m.total })),
+  }
+}
+
+function detectCardDir(dir) {
+  const schema = path.join(dir, 'schema.json')
+  if (!exists(schema)) return { matched: false }
+  return {
+    matched: true,
+    confidence: 'high',
+    evidence: [`schema.json（已存在卡片 ${path.basename(dir)}）`, exists(path.join(dir, 'data.json')) ? 'data.json' : 'data.json 缺失'],
+    schema,
+  }
+}
+
+function route(inputAbs) {
+  if (isDir(inputAbs)) {
+    const card = detectCardDir(inputAbs)
+    if (card.matched) {
+      return {
+        kind: 'card-dir',
+        confidence: card.confidence,
+        evidence: card.evidence,
+        skillChain: ['dsl-card-generator'],
+        workflow: 'Workflow B — 编辑已有卡片',
+        next: [
+          `node ${shortPath(path.join(skillsDir, 'dsl-card-generator', 'scripts', 'describe_card.mjs'))} --id ${path.basename(inputAbs)}`,
+          `node ${shortPath(path.join(skillsDir, 'dsl-card-generator', 'scripts', 'diff_card.mjs'))} --id ${path.basename(inputAbs)}`,
+        ],
+        note: '输入已是卡片目录，走编辑链路（card_node_models 定位 + add_component 增改 + diff_card 兜底），不需要设计稿前处理。',
+      }
+    }
+
+    const meaxure = detectMeaxure(inputAbs)
+    if (meaxure.matched) {
+      const done = findPreprocessed(inputAbs)
+      const draft = (done && done.draft) || path.basename(inputAbs)
+      const uiDir = done ? done.uiDir : path.join(UI_ROOT, draft)
+      const parse = path.join(SKETCH_SKILL, 'scripts', 'parse_meaxure.py')
+      const cluster = path.join(SKETCH_SKILL, 'scripts', 'cluster_states.py')
+      const py = pythonBin()
+      const uiRel = shortPath(uiDir)
+      return {
+        kind: 'meaxure-export',
+        confidence: meaxure.confidence,
+        evidence: meaxure.evidence,
+        skillChain: done ? ['dsl-card-generator'] : ['sketch-spec-to-card', 'dsl-card-generator'],
+        workflow: done ? 'Workflow 0 入口② → 选卡后 Workflow A（单画板）' : 'Workflow 0 入口① → 先 sketch-spec-to-card 前处理',
+        preprocess: {
+          needed: !done,
+          draft,
+          uiDir: uiRel,
+          uiRoot: shortPath(UI_ROOT),
+          manifest: done ? shortPath(done.manifest) : null,
+          matchedVia: done ? done.via : null,
+          // 主产物里已生成 / 总画板数，以及同一导出的其它产物目录（平铺与按稿分片并存时）
+          generated: done ? done.generated : 0,
+          total: done ? done.total : 0,
+          alsoFound: done && done.alsoFound.length ? done.alsoFound : undefined,
+        },
+        next: done
+          ? [
+              `# 多画板门禁（rules.md §十三）：产物已存在≠已选卡。先跑下面这条只读 --list 取全量画板清单（1..n + 全部），交给用户并停止输出等回复，再消费产物`,
+              `${py} ${shortPath(parse)} --src "${inputAbs}" --draft "${draft}" --list`,
+              SELECTION_GATE,
+              `# 拿到回复后（产物已存在，${done.via}，已生成 ${done.generated}/${done.total} 画板），跳过前处理，只消费用户指定的那个画板：`,
+              `cat ${shortPath(done.manifest)}`,
+              `node ${shortPath(path.join(skillsDir, 'dsl-card-generator', 'scripts', 'spec_tree.mjs'))} --spec ${shortPath(path.join(uiDir, '<画板>', 'spec.json'))}`,
+              ...(done.alsoFound && done.alsoFound.length
+                ? [`# 同一导出另有产物目录（目标画板在主 manifest 里是 pending 时先去这些目录找，找到就直接用，别重跑管线）：${done.alsoFound.map((m) => `${m.uiDir}（已生成 ${m.generated}/${m.total}）`).join('、')}`]
+                : []),
+              `# 用户回「全部」= 显式批量授权：可重跑管线补齐缺失画板（${py} ${shortPath(parse)} --src "${inputAbs}" --out "${shortPath(UI_ROOT)}" --draft "${draft}" --scope-all --build）`,
+            ]
+          : [
+              `# 多画板门禁（rules.md §十三）：先 --list 列 1..n + 全部 并停下等用户回复；下面 parse 不带范围直接跑会 exit 4`,
+              `${py} ${shortPath(parse)} --src "${inputAbs}" --out "${shortPath(UI_ROOT)}" --draft "${draft}" --build`,
+              `# 拿到回复后给上一条 parse 命令补范围：序号 k → --indices <k-1>；「全部」→ --scope-all`,
+              `${py} ${shortPath(cluster)} --out "${uiRel}"`,
+              SELECTION_GATE,
+            ],
+        note: done
+          ? 'UI/ 下已有该导出的产物，不重复跑管线；按 manifest.json / clusters.json 选卡后走 Workflow A（每轮只产用户指定的那一张卡），overlay_dialog 走 Workflow A.5（不产卡，补到父卡事件）。多画板未指定目标时先列清单请用户选，禁止自行挑画板或擅自批量（rules.md §十三）。'
+          : 'MeaXure 导出是多画板批量输入：禁止直接读 preview/ 整图建卡，必须先由 sketch-spec-to-card 做卡片聚焦裁切、多卡分离、弹窗识别与切图收集，产出 UI/<稿名>/ 要素包后回本 skill 生成。UI 产物可全量生成，卡片生成以用户指定的单画板 / 单 cardKey 为单位（rules.md §十三）。',
+      }
+    }
+
+    const bundle = detectUiBundle(inputAbs)
+    if (bundle.matched) {
+      const specHint = bundle.specJson
+        ? `node ${shortPath(path.join(skillsDir, 'dsl-card-generator', 'scripts', 'spec_tree.mjs'))} --spec ${shortPath(bundle.specJson)}`
+        : `cat ${shortPath(bundle.manifest || inputAbs)}`
+      return {
+        kind: 'ui-bundle',
+        confidence: bundle.confidence,
+        evidence: bundle.evidence,
+        skillChain: ['dsl-card-generator'],
+        workflow: bundle.artboardBundle ? 'Workflow A（单画板要素包）' : 'Workflow 0 入口② → 选卡后 Workflow A（单画板）',
+        bundle: {
+          manifest: bundle.manifest ? shortPath(bundle.manifest) : null,
+          clusters: bundle.clusters ? shortPath(bundle.clusters) : null,
+          specJson: bundle.specJson ? shortPath(bundle.specJson) : null,
+          cardImages: bundle.cardImages,
+          boards: bundle.boards.length,
+        },
+        next: [
+          specHint,
+          `# 再按 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 分流。',
+      }
+    }
+
+    const images = entries(inputAbs).filter((e) => e.isFile() && IMAGE_EXT.has(path.extname(e.name).toLowerCase()))
+    if (images.length === 1) {
+      return route(path.join(inputAbs, images[0].name))
+    }
+    return {
+      kind: 'unknown',
+      confidence: 'low',
+      evidence: [
+        `目录内 ${entries(inputAbs).length} 项，未命中 MeaXure 签名（index.html + artboards）`,
+        '未命中 UI 要素包签名（manifest.json / spec.json + card-N.png）',
+        images.length ? `含 ${images.length} 张图片（多张，无法自动判定哪张是设计稿）` : '无图片文件',
+      ],
+      skillChain: [],
+      workflow: '需人工确认',
+      next: ['# 请指明输入形态：MeaXure 导出目录 / UI 要素包 / 单张设计稿 PNG / 已有卡片目录'],
+      note: '判不出形态时不要猜：向用户确认输入，或显式指定 UI/<画板>/spec.json 与 card-N.png。',
+    }
+  }
+
+  const ext = path.extname(inputAbs).toLowerCase()
+  if (IMAGE_EXT.has(ext)) {
+    const siblingSpec = path.join(path.dirname(inputAbs), 'spec.json')
+    if (exists(siblingSpec)) return route(path.dirname(inputAbs))
+    return {
+      kind: 'image',
+      confidence: 'high',
+      evidence: [`单张图片 ${path.basename(inputAbs)}（同目录无 spec.json）`],
+      skillChain: ['dsl-card-generator'],
+      workflow: 'Workflow 0 入口③ → Workflow A（无标注，视觉推断）',
+      next: [`# 直接多模态读图 → scaffold_card 出骨架 → validate+lint → render_diff 视觉闭环`],
+      note: '无 MeaXure 标注时全靠 AI 视觉推断，间距/圆角从图上目视估算；若这张图其实来自某份标注导出，请改传导出目录以走入口①。',
+    }
+  }
+
+  if (ENTRY_FILES.has(path.basename(inputAbs).toLowerCase())) {
+    return route(path.dirname(inputAbs))
+  }
+
+  return {
+    kind: 'unknown',
+    confidence: 'low',
+    evidence: [`文件 ${path.basename(inputAbs)}（${ext || '无扩展名'}）不是图片，也不是目录入口`],
+    skillChain: [],
+    workflow: '需人工确认',
+    next: ['# 传目录（MeaXure 导出 / UI 要素包 / 卡片目录）或设计稿 PNG'],
+    note: '判不出形态时不要猜：向用户确认输入。',
+  }
+}
+
+function printHuman(result, inputAbs) {
+  const icon = { 'meaxure-export': '🧭', 'ui-bundle': '📦', 'card-dir': '✏️', image: '🖼️', unknown: '❓' }[result.kind] || '•'
+  const label = {
+    'meaxure-export': 'Sketch MeaXure 标注导出目录',
+    'ui-bundle': 'sketch-spec-to-card 产物（UI 要素包）',
+    'card-dir': '已存在卡片目录',
+    image: '单张设计稿图片',
+    unknown: '未识别形态',
+  }[result.kind]
+  console.log(`${icon} 输入路由：${result.kind} — ${label}（置信度 ${result.confidence}）`)
+  console.log(`   输入：${shortPath(inputAbs)}`)
+  console.log(`   证据：${result.evidence.join('；')}`)
+  console.log(`   链路：${result.skillChain.length ? result.skillChain.join(' → ') : '（待定）'}｜${result.workflow}`)
+  if (result.preprocess) {
+    const p = result.preprocess
+    console.log(`   前处理：${p.needed ? `需要（稿名建议 "${p.draft}" → ${p.uiDir}）` : `已存在，跳过（${p.matchedVia}；manifest=${p.manifest}）`}`)
+  }
+  console.log('   下一步：')
+  for (const line of result.next) console.log(`     ${line}`)
+  console.log(`   说明：${result.note}`)
+}
+
+/**
+ * 判定入口（CLI 与 MCP `card_route_input` 共用同一份实现，避免漂移）。
+ * 不打印、不 process.exit，只返回结构化结果；路径不存在时返回 `error` 字段。
+ * @param {string} input 输入路径（相对路径按 cwd 解析）
+ * @returns {object} `{ input, inputAbs, kind, confidence, evidence, skillChain, workflow, next, note, ... }`
+ */
+export function routeInput(input) {
+  const raw = String(input == null ? '' : input)
+  const inputAbs = path.resolve(raw)
+  if (!raw.trim() || !exists(inputAbs)) {
+    return { input: raw, inputAbs, error: 'input-not-found', message: `输入路径不存在：${inputAbs}` }
+  }
+  return { input: shortPath(inputAbs), inputAbs, ...route(inputAbs) }
+}
+
+function main() {
+  const argv = process.argv.slice(2)
+  const asJson = argv.includes('--json')
+  const rest = argv.filter((a) => a !== '--json')
+  if (!rest.length) {
+    console.error('[usage] node route_input.mjs <输入路径（MeaXure 导出目录 / UI 要素包 / 卡片目录 / 设计稿 PNG）> [--json]')
+    process.exit(1)
+  }
+  const result = routeInput(rest[0])
+  if (result.error) {
+    console.error(`[error] ${result.message}`)
+    process.exit(1)
+  }
+  if (asJson) console.log(JSON.stringify(result, null, 2))
+  else printHuman(result, result.inputAbs)
+  process.exit(result.kind === 'unknown' ? 3 : 0)
+}
+
+// 只有被直接执行时才跑 CLI；被 MCP client 动态 import 时只取 routeInput，不触发 process.exit
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main()

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

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * scaffold_card.mjs — 秒出合法卡片骨架，避免手写组件样板。
+ *
+ * 用法：
+ *   node scaffold_card.mjs --intent list --id myCard --name "我的卡"
+ *   node scaffold_card.mjs --intent form --id f1 --name "表单" --out /tmp/cards --force
+ *   node scaffold_card.mjs --from creditCardBill --id myNewCard --name "新卡"   # 整卡模板克隆
+ *
+ * 意图：blank | list | detail | form | dialog | tab | canvas-head
+ * 输出：<outBase>/<id>/{schema.json, data.json}（data.json 由 inputParams 反推，自洽）
+ *
+ * 设计：形状来自 lib/scaffold.mjs（与 gen-all-components-test 同源），保证合法。
+ * --from 模式：克隆存量整卡模板（references/card_templates.json 提供簇→代表卡路由），
+ * 只重写 pageId/name，版式纪律与范式原样继承；封面不复制（需定稿后重新渲染）。
+ */
+import path from 'node:path'
+import fs from 'node:fs'
+import { writeSkeleton, cloneCardFrom, SCAFFOLD_INTENTS } from './lib/scaffold.mjs'
+
+function parseArgs(argv) {
+  const out = {}
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (!a.startsWith('--')) continue
+    const key = a.slice(2)
+    const next = argv[i + 1]
+    if (next && !next.startsWith('--')) { out[key] = next; i++ } else out[key] = true
+  }
+  return out
+}
+
+const args = parseArgs(process.argv.slice(2))
+const intent = args.intent || args.i
+const from = args.from
+const id = args.id
+const name = args.name || args.n
+const outBase = args.out ? path.resolve(args.out) : undefined
+const force = !!args.force
+
+if (!from && (!intent || !SCAFFOLD_INTENTS.includes(intent))) {
+  console.error(`[usage] --intent <${SCAFFOLD_INTENTS.join('|')}> --id <cardId> [--name <名称>] [--out <dir>] [--force]`)
+  console.error(`     或 --from <模板卡id> --id <cardId> [--name <名称>] [--force]（整卡模板克隆，模板见 references/card_templates.json）`)
+  process.exit(1)
+}
+if (!id) {
+  console.error('[error] 缺少 --id <cardId>')
+  process.exit(1)
+}
+
+if (force && outBase) {
+  const dir = path.join(outBase, id)
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true, force: true })
+}
+
+try {
+  if (from) {
+    const dir = cloneCardFrom(from, id, { name, outBase })
+    console.log(`[ok] 已克隆模板卡：${from} → ${dir}`)
+    console.log(`     注意：封面未复制（封面必须代表卡片自身外观），结构定稿后重新渲染生成`)
+  } else {
+    const dir = writeSkeleton(id, intent, { name, outBase, force })
+    console.log(`[ok] 已生成骨架：${dir}`)
+    console.log(`     意图=${intent}  组件树=/Root>${describe(intent)}`)
+  }
+} catch (e) {
+  console.error('[error] ' + e.message)
+  process.exit(1)
+}
+
+function describe(intent) {
+  return {
+    blank: '（空容器）',
+    list: 'Column > Text($title) + ListLayout($list)',
+    detail: 'Column > Text($title) + ListLayout($detailList) + Button',
+    form: 'Column > Text($title) + Input×2 + Button',
+    dialog: 'Column > Text($title) + Text($desc) + Button',
+    tab: 'Column > Row(tabs) + Column(panel)',
+    'canvas-head': 'Column > Row(Canvas + Text)',
+  }[intent] || ''
+}