mini-figma-code-connect 0.1.0 → 0.1.3

package/scripts/install-skill.mjs

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { isCliEntrypoint } from './is-cli-entrypoint.mjs';
-
-const PACKAGE_ROOT = path.resolve(fileURLToPath(import.meta.url), '../..');
-const SKILL_SOURCE = path.join(PACKAGE_ROOT, '.claude/skills/mini-code-connect');
-const SKILL_NAME = 'mini-code-connect';
-
-/**
- * `.claude/`、`.agents/` 这些约定都是挂在 git 仓库根目录的，不是随便哪个 cwd。
- * pnpm monorepo 里这个包大概率是某个子包（比如 apps/rexy）的 devDependency，
- * 从那跑命令 cwd 就是子包目录，不是仓库根——得从 cwd 往上找到 .git 所在的那一层。
- * 找不到 .git（比如根本不在 git 仓库里）就退回用 cwd 本身，不报错。
- */
-function findRepoRoot(cwd) {
-  let dir = cwd;
-  while (true) {
-    if (fs.existsSync(path.join(dir, '.git'))) return dir;
-    const parent = path.dirname(dir);
-    if (parent === dir) return cwd; // 到根了还没找到 .git，放弃，退回 cwd
-    dir = parent;
-  }
-}
-
-/**
- * 把这个包自带的 mini-code-connect skill 复制进消费方项目——Claude Code 只认消费方
- * 项目自己 `.claude/skills/` 下的文件，装了这个 npm 包不代表 skill 会被发现，
- * 得实际把 SKILL.md 落到消费方项目里才能用 /mini-code-connect 或自然语言触发。
- *
- * 默认复制进 `.claude/skills/`（Claude Code 自己认的位置）；如果项目根目录已经有
- * `.agents/skills/`（多 agent 工具共享 skill 的常见约定，比如 trex-website 就是这样），
- * 额外复制一份进去——不强求消费方一定要有这个目录，检测到才复制。两份都写是因为不确定
- * 消费方是否有自动把 `.agents/skills/` 同步进 `.claude/skills/` 的机制；如果消费方项目
- * 自己已经有这类同步工具，`.claude/skills/` 这份可以不用管（or 加 opts.claudeMirror: false
- * 关掉，避免跟同步工具打架）。
- *
- * @param {object} opts
- * @param {string} opts.cwd 运行这个命令时所在的目录（子包 cwd 也行，会自动找仓库根）
- * @param {string} [opts.root] 显式指定目标根目录，跳过自动探测 .git
- * @param {boolean} [opts.force] 目标已存在时是否覆盖，默认不覆盖（避免吃掉消费方自己的改动）
- * @param {boolean} [opts.claudeMirror] 是否也写一份进 `.claude/skills/`，默认 true
- */
-export function installSkill({ cwd, root, force = false, claudeMirror = true }) {
-  const base = root ?? findRepoRoot(cwd);
-  const targets = [];
-  if (claudeMirror) targets.push(path.join(base, '.claude/skills', SKILL_NAME));
-  if (fs.existsSync(path.join(base, '.agents/skills'))) {
-    targets.push(path.join(base, '.agents/skills', SKILL_NAME));
-  }
-
-  const results = [];
-  for (const target of targets) {
-    if (fs.existsSync(target) && !force) {
-      results.push({ target, skipped: true });
-      continue;
-    }
-    fs.rmSync(target, { recursive: true, force: true });
-    fs.cpSync(SKILL_SOURCE, target, { recursive: true });
-    results.push({ target, skipped: false });
-  }
-  return { results, root: base };
-}
-
-if (isCliEntrypoint(import.meta.url)) {
-  const args = process.argv.slice(2);
-  const force = args.includes('--force');
-  const noClaudeMirror = args.includes('--no-claude-mirror');
-  const rootIdx = args.indexOf('--root');
-  const root = rootIdx !== -1 ? path.resolve(args[rootIdx + 1]) : undefined;
-
-  const { results, root: usedRoot } = installSkill({ cwd: process.cwd(), root, force, claudeMirror: !noClaudeMirror });
-  console.log(`[install-skill] 项目根目录：${usedRoot}`);
-  for (const r of results) {
-    console.log(r.skipped ? `[install-skill] 已存在，跳过（加 --force 覆盖）：${r.target}` : `[install-skill] 已写入：${r.target}`);
-  }
-  console.log('\n跑 /mini-code-connect（或直接说"帮我映射这个 Figma 组件"）触发 skill。');
-}

package/scripts/is-cli-entrypoint.mjs

@@ -1,21 +0,0 @@
-import { realpathSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-/**
- * "这个模块是不是被直接当 CLI 跑的（而不是被 import）" 的正确判断。
- *
- * `import.meta.url === \`file://${process.argv[1]}\`` 这种写法几乎总是 false：
- * process.argv[1] 是命令行原样传入的路径（常见是相对路径，比如 `node scripts/x.mjs`
- * 或经 pnpm bin 软链调用时是 `node_modules/pkg/scripts/x.mjs`），既没转绝对路径也没解析
- * 符号链接；import.meta.url 则永远是绝对路径，且经过符号链接解析（这个包大概率是通过
- * `link:` 装的，实际文件在别处）。两边格式对不上，条件永远不成立，CLI 分支静默不执行。
- * 用 realpathSync 把两边都归一化到真实绝对路径再比较。
- */
-export function isCliEntrypoint(importMetaUrl) {
-  if (!process.argv[1]) return false;
-  try {
-    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(importMetaUrl));
-  } catch {
-    return false; // argv[1] 不是个真实文件路径（比如 REPL/-e）时 realpathSync 会抛
-  }
-}

package/scripts/scaffold-manifest.mjs

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { isCliEntrypoint } from './is-cli-entrypoint.mjs';
-
-/**
- * 生成消费方项目自己的 manifest.json + manifest.codegen.json —— 两份 Figma 插件清单，
- * `main`/`ui` 指向消费方自己 buildPlugin() 的产物目录（outDir 得跟 buildPlugin() 调用时传的
- * 一致，两边各自维护，这个函数不做校验）。已存在的文件不覆盖，避免吃掉消费方自己加的字段
- * （比如 codegenLanguages 加了更多语言）——要重新生成就先手动删掉旧文件。
- *
- * 两份清单必须分开：官方 codegen 插件要求 editorType 只能是 ["dev"]，跟 "figma"/"inspect"
- * 写一起 Figma 会报错。
- *
- * @param {object} opts
- * @param {string} opts.cwd 消费方项目根目录，manifest 写在这里
- * @param {string} [opts.name] 面板插件在 Figma 里显示的名字，默认 'Mini Code Connect'——
- *   Figma 账号里同时装了多个消费方的插件时会撞名（区分靠 id，不靠 name），需要区分再传
- * @param {string} opts.id 面板插件的 manifest id，同一账号内必须唯一，例如 'trex-rexy-code-connect'
- * @param {string} [opts.outDir] 相对 cwd 的构建产物目录，须跟 buildPlugin() 的 outDir 一致，默认 'dist'
- */
-export function scaffoldManifest({ cwd, name = 'Mini Code Connect', id, outDir = 'dist' }) {
-  if (!id) throw new Error('scaffoldManifest: id 必填');
-
-  const panel = {
-    name,
-    id,
-    api: '1.0.0',
-    main: `${outDir}/code.js`,
-    ui: `${outDir}/ui.html`,
-    editorType: ['figma', 'dev'],
-    capabilities: ['inspect'],
-    documentAccess: 'dynamic-page',
-    networkAccess: { allowedDomains: ['none'] },
-  };
-  const codegen = {
-    name: `${name} (Codegen)`,
-    id: `${id}-codegen`,
-    api: '1.0.0',
-    main: `${outDir}/code.js`,
-    ui: `${outDir}/ui.html`,
-    editorType: ['dev'],
-    capabilities: ['codegen'],
-    codegenLanguages: [{ label: 'React', value: 'react' }],
-    documentAccess: 'dynamic-page',
-    networkAccess: { allowedDomains: ['none'] },
-  };
-
-  const results = [];
-  for (const [file, content] of [
-    ['manifest.json', panel],
-    ['manifest.codegen.json', codegen],
-  ]) {
-    const target = path.join(cwd, file);
-    if (fs.existsSync(target)) {
-      results.push({ target, skipped: true });
-      continue;
-    }
-    fs.writeFileSync(target, JSON.stringify(content, null, 2) + '\n');
-    results.push({ target, skipped: false });
-  }
-  return { results };
-}
-
-if (isCliEntrypoint(import.meta.url)) {
-  const args = process.argv.slice(2);
-  const get = (flag) => {
-    const i = args.indexOf(flag);
-    return i === -1 ? undefined : args[i + 1];
-  };
-  const name = get('--name') ?? 'Mini Code Connect';
-  const id = get('--id');
-  const outDir = get('--out') ?? 'dist';
-
-  if (!id) {
-    console.error('用法: node scripts/scaffold-manifest.mjs --id <manifest-id> [--name "<面板显示名>"] [--out dist]');
-    process.exit(1);
-  }
-
-  const { results } = scaffoldManifest({ cwd: process.cwd(), name, id, outDir });
-  for (const r of results) {
-    console.log(r.skipped ? `[scaffold-manifest] 已存在，跳过：${r.target}` : `[scaffold-manifest] 已写入：${r.target}`);
-  }
-}

package/scripts/scaffold-plugin.mjs

@@ -1,172 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { installSkill } from './install-skill.mjs';
-import { scaffoldManifest } from './scaffold-manifest.mjs';
-import { buildPlugin } from './build-plugin.mjs';
-import { isCliEntrypoint } from './is-cli-entrypoint.mjs';
-
-/**
- * 一条命令做完消费方接入的全部一次性脚手架：skill、候选目录配置、manifest、构建脚本、
- * package.json 里的 figma:build/figma:watch、.gitignore，最后自己跑一次 build——跑完就是
- * 能直接导入 Figma 的状态，不需要再手动补一次 `pnpm run figma:build`（少一步就少一次"跑完
- * 以为完事了，其实产物没生成"的坑）。唯一必须消费方自己敲的只剩：
- *   `pnpm add -D mini-figma-code-connect` —— 得先装上这个包，这个函数才存在
- * 装好真实映射后的后续 build（改完 .figma.ts 要重新打包）继续用 `pnpm run figma:build`/
- * `figma:watch`，那是常态操作，不是这个一次性 setup 的一部分。
- *
- * 幂等：每一步该跳过就跳过（已存在的文件不覆盖，package.json 已有的 script key 不覆盖），
- * 重复跑不会把消费方自己后续的修改吃掉；末尾的 build 步骤本身也是幂等操作，可以放心重跑。
- *
- * @param {object} opts
- * @param {string} opts.cwd 消费方子项目根目录（manifest/config/构建脚本都落在这里，比如 apps/rexy）
- * @param {string} [opts.name] 插件在 Figma 里显示的名字，默认 'Mini Code Connect'——账号里同时
- *   装了多个消费方的插件时会撞名（区分靠 id，不靠 name），需要区分再传
- * @param {string} opts.id manifest id，同一账号内必须唯一，例如 'trex-rexy-code-connect'
- * @param {string} [opts.outDir] 构建产物目录，默认 'figma-plugin-dist'
- * @param {string} [opts.componentsDir] 候选组件目录（相对 cwd），默认 'components'
- * @param {string} [opts.mappingsGlob] .figma.ts 的 glob（相对 cwd），默认 'figma-mappings/**\/*.figma.ts'
- * @param {string} [opts.mappingTablePath] mapping-table.json 路径（相对 cwd），默认 'figma-mapping-table.json'
- * @param {string} [opts.root] 传给 installSkill 的仓库根覆盖，不传就自动探测 .git
- * @param {boolean} [opts.force] 已存在的文件/script key 也覆盖
- */
-export async function scaffoldPlugin({
-  cwd,
-  name = 'Mini Code Connect',
-  id,
-  outDir = 'figma-plugin-dist',
-  componentsDir = 'components',
-  mappingsGlob = 'figma-mappings/**/*.figma.ts',
-  mappingTablePath = 'figma-mapping-table.json',
-  root,
-  force = false,
-}) {
-  if (!id) throw new Error('scaffoldPlugin: id 必填');
-
-  const steps = [];
-
-  const skill = installSkill({ cwd, root, force });
-  steps.push({ step: 'install-skill', ...skill });
-
-  const configPath = path.join(cwd, 'figma-mapping.config.json');
-  if (fs.existsSync(configPath) && !force) {
-    steps.push({ step: 'config', target: configPath, skipped: true });
-  } else {
-    const config = {
-      codeConnect: {
-        paths: { [path.basename(componentsDir)]: componentsDir },
-        importPaths: { [`${componentsDir}/*`]: `@/${componentsDir}/*` },
-      },
-    };
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-    steps.push({ step: 'config', target: configPath, skipped: false });
-  }
-
-  const manifest = scaffoldManifest({ cwd, name, id, outDir });
-  steps.push({ step: 'manifest', ...manifest });
-
-  const buildScriptPath = path.join(cwd, 'scripts/build-figma-plugin.mjs');
-  if (fs.existsSync(buildScriptPath) && !force) {
-    steps.push({ step: 'build-script', target: buildScriptPath, skipped: true });
-  } else {
-    const buildScript = `#!/usr/bin/env node
-import { buildPlugin } from 'mini-figma-code-connect/build'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-await buildPlugin({
-  cwd: path.resolve(fileURLToPath(import.meta.url), '../..'),
-  mappingsGlob: ${JSON.stringify(mappingsGlob)},
-  mappingTablePath: ${JSON.stringify(mappingTablePath)},
-  outDir: ${JSON.stringify(outDir)},
-  watch: process.argv.includes('--watch'),
-})
-`;
-    fs.mkdirSync(path.dirname(buildScriptPath), { recursive: true });
-    fs.writeFileSync(buildScriptPath, buildScript);
-    steps.push({ step: 'build-script', target: buildScriptPath, skipped: false });
-  }
-
-  const pkgPath = path.join(cwd, 'package.json');
-  if (!fs.existsSync(pkgPath)) {
-    steps.push({ step: 'package-json-scripts', target: pkgPath, skipped: true, reason: 'package.json 不存在' });
-  } else {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    pkg.scripts ??= {};
-    const already = pkg.scripts['figma:build'] !== undefined || pkg.scripts['figma:watch'] !== undefined;
-    if (already && !force) {
-      steps.push({ step: 'package-json-scripts', target: pkgPath, skipped: true, reason: 'figma:build/figma:watch 已存在' });
-    } else {
-      pkg.scripts['figma:build'] = 'node scripts/build-figma-plugin.mjs';
-      pkg.scripts['figma:watch'] = 'node scripts/build-figma-plugin.mjs --watch';
-      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-      steps.push({ step: 'package-json-scripts', target: pkgPath, skipped: false });
-    }
-  }
-
-  // 构建产物是生成物，不该进消费方的版本控制——确保 .gitignore 里有这条，不存在就补，
-  // 不去重复判断 force：加一行已经存在的 ignore 规则没有"覆盖"这个概念，本身就是幂等的。
-  const gitignorePath = path.join(cwd, '.gitignore');
-  const ignoreEntry = `/${outDir}`;
-  const existing = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, 'utf8') : '';
-  const alreadyIgnored = existing.split('\n').some((l) => l.trim() === ignoreEntry || l.trim() === outDir);
-  if (alreadyIgnored) {
-    steps.push({ step: 'gitignore', target: gitignorePath, skipped: true });
-  } else {
-    const sep = existing === '' || existing.endsWith('\n') ? '' : '\n';
-    fs.writeFileSync(gitignorePath, `${existing}${sep}\n# figma code connect 插件构建产物\n${ignoreEntry}\n`);
-    steps.push({ step: 'gitignore', target: gitignorePath, skipped: false });
-  }
-
-  // 跑完这一步，产物就绪、manifest 就绪，直接能导入 Figma——不依赖消费方记得再手动跑一次
-  // build。此时大概率还没有真实映射（figma-mappings/ 为空），产出的是零映射插件，正常。
-  await buildPlugin({ cwd, mappingsGlob, mappingTablePath, outDir });
-  steps.push({ step: 'build', target: path.join(cwd, outDir), skipped: false });
-
-  return { steps };
-}
-
-if (isCliEntrypoint(import.meta.url)) {
-  const args = process.argv.slice(2);
-  const get = (flag, fallback) => {
-    const i = args.indexOf(flag);
-    return i === -1 ? fallback : args[i + 1];
-  };
-  const name = get('--name') ?? 'Mini Code Connect';
-  const id = get('--id');
-  if (!id) {
-    console.error(
-      '用法: node scripts/scaffold-plugin.mjs --id <manifest-id> ' +
-        '[--name "<面板显示名>"] [--out figma-plugin-dist] [--components components] [--force]',
-    );
-    process.exit(1);
-  }
-
-  const { steps } = await scaffoldPlugin({
-    cwd: process.cwd(),
-    name,
-    id,
-    outDir: get('--out', 'figma-plugin-dist'),
-    componentsDir: get('--components', 'components'),
-    force: args.includes('--force'),
-  });
-
-  for (const s of steps) {
-    if (s.results) {
-      for (const r of s.results) {
-        console.log(r.skipped ? `[scaffold-plugin] [${s.step}] 已存在，跳过：${r.target}` : `[scaffold-plugin] [${s.step}] 已写入：${r.target}`);
-      }
-    } else {
-      console.log(
-        s.skipped
-          ? `[scaffold-plugin] [${s.step}] 已存在，跳过：${s.target}${s.reason ? `（${s.reason}）` : ''}`
-          : `[scaffold-plugin] [${s.step}] 已写入：${s.target}`,
-      );
-    }
-  }
-  console.log(
-    '\n已经可以导入 Figma 了（Plugins → Development → Import plugin from manifest… 选 manifest.json）。' +
-      '\n候选组件目录不是默认的 components/ 的话，编辑 figma-mapping.config.json 再改；' +
-      '\n建好真实映射后用 `pnpm run figma:build`（或 `figma:watch`）重新打包。',
-  );
-}

package/src/dev/demo.ts

@@ -1,207 +0,0 @@
-/**
- * 不开 Figma 也能验证映射：用假实例喂给一份模板。
- * 跑 `npm run demo`。
- *
- * 模板内联在本文件里，不挂靠任何消费方的 `figma-mappings/` 或 registry —— 这样这个演示脚本
- * 不受实际映射内容变动（增删组件）影响，专门用来讲解运行时机制。
- */
-import { renderToString } from '../runtime/render'
-import { validate } from '../main/validate'
-import type {
-  AccessorCall,
-  ComponentSchema,
-  ErrorLike,
-  InstanceLike,
-  Template,
-  TemplateResult,
-  TextLike,
-} from '../runtime/types'
-
-type MockNode = {
-  component: string
-  props: Record<string, string | boolean>
-  swaps?: Record<string, MockNode>
-}
-
-class ErrorHandle implements ErrorLike {
-  readonly type = 'ERROR' as const
-  constructor(readonly message: string) {}
-}
-
-class MockInstance implements InstanceLike {
-  readonly type = 'INSTANCE' as const
-  constructor(
-    private node: MockNode,
-    private calls: AccessorCall[],
-    private depth = 0,
-    private probe = false,
-  ) {}
-
-  get name(): string {
-    return this.node.component
-  }
-
-  private log(c: Omit<AccessorCall, 'depth'>): void {
-    this.calls.push({ ...c, depth: this.depth })
-  }
-
-  getString(prop: string): string {
-    const v = this.node.props[prop]
-    if (v === undefined) {
-      this.log({ prop, method: 'getString', ok: false, note: '属性不存在' })
-      return ''
-    }
-    this.log({ prop, method: 'getString', ok: true })
-    return String(v)
-  }
-
-  getBoolean(prop: string): boolean
-  getBoolean<T>(prop: string, mapping: { true: T; false: T }): T
-  getBoolean(prop: string, mapping?: { true: unknown; false: unknown }): unknown {
-    const v = this.node.props[prop]
-    if (v === undefined) {
-      this.log({ prop, method: 'getBoolean', ok: false, note: '属性不存在' })
-      return mapping ? mapping.false : false
-    }
-    this.log({ prop, method: 'getBoolean', ok: true })
-    const b = this.probe ? true : v === true || v === 'true'
-    return mapping ? (b ? mapping.true : mapping.false) : b
-  }
-
-  getEnum<T>(prop: string, mapping: Record<string, T>): T | undefined {
-    const keys = Object.keys(mapping)
-    const v = this.node.props[prop]
-    if (v === undefined) {
-      this.log({ prop, method: 'getEnum', mappingKeys: keys, ok: false, note: '属性不存在' })
-      return undefined
-    }
-    const raw = String(v)
-    const hit = Object.prototype.hasOwnProperty.call(mapping, raw)
-    this.log({
-      prop,
-      method: 'getEnum',
-      mappingKeys: keys,
-      ok: hit,
-      note: hit ? undefined : `当前值 "${raw}" 不在字典里，返回了 undefined`,
-    })
-    return hit ? mapping[raw] : undefined
-  }
-
-  getInstanceSwap(prop: string): InstanceLike | ErrorLike | null {
-    const child = this.node.swaps?.[prop]
-    if (!child) {
-      this.log({ prop, method: 'getInstanceSwap', ok: false, note: '找不到绑定该属性的子实例' })
-      return new ErrorHandle(`找不到 instance swap 插槽 "${prop}"`)
-    }
-    this.log({ prop, method: 'getInstanceSwap', ok: true })
-    return new MockInstance(child, this.calls, this.depth + 1, this.probe)
-  }
-
-  findInstance(layerName: string): InstanceLike | ErrorLike {
-    return new ErrorHandle(`demo 不支持 findInstance("${layerName}")`)
-  }
-
-  findText(layerName: string): TextLike | ErrorLike {
-    return new ErrorHandle(`demo 不支持 findText("${layerName}")`)
-  }
-
-  hasCodeConnect(): boolean {
-    return this.node.swaps !== undefined
-  }
-  codeConnectId(): string | null {
-    return null
-  }
-  executeTemplate(): TemplateResult | null {
-    return {
-      example: [{ type: 'INSTANCE', guid: 'mock', symbolId: '', name: this.node.component }],
-      id: 'unmapped',
-    }
-  }
-}
-
-/** 独立的一份演示模板：Button ↔ <Button variant="..." size="..." /> */
-const buttonTemplate: Template = {
-  id: 'demo-button',
-  meta: { url: 'demo', source: 'demo', component: 'Button' },
-  match: { componentName: 'Button' },
-  render(instance) {
-    const label = instance.getString('Label')
-    const variant = instance.getEnum('Variant', { Primary: 'primary', Secondary: 'secondary', Ghost: 'ghost' })
-    const size = instance.getEnum('Size', { Small: 'sm', Medium: 'md', Large: 'lg' })
-    const disabled = instance.getBoolean('Disabled')
-    const hasIcon = instance.getBoolean('Has Icon')
-
-    const icon = hasIcon ? instance.getInstanceSwap('Icon') : null
-    let iconCode
-    if (icon && icon.type === 'INSTANCE') {
-      const name = icon.name === 'Icon' ? 'arrow' : icon.name.toLowerCase()
-      iconCode = [{ type: 'CODE' as const, code: `<Icon name="${name}" />` }]
-    }
-
-    return {
-      example: [
-        { type: 'CODE', code: `<Button\n  variant="${variant}"\n  size="${size}"` },
-        ...(disabled ? [{ type: 'CODE' as const, code: '\n  disabled' }] : []),
-        ...(iconCode ? [{ type: 'CODE' as const, code: '\n  icon={' }, ...iconCode, { type: 'CODE' as const, code: '}' }] : []),
-        { type: 'CODE', code: `\n>\n  ${label}\n</Button>` },
-      ],
-      imports: ['import { Button } from "primitives"'],
-      id: 'demo-button',
-      metadata: { nestable: true },
-    }
-  },
-}
-
-/** 手写一份等价于 get_context_for_code_connect 返回的 schema，用于自检 */
-const buttonSchema: ComponentSchema = {
-  componentId: '1:2',
-  componentKey: 'mock-button-key',
-  componentName: 'Button',
-  properties: [
-    { name: 'Label', type: 'TEXT' },
-    { name: 'Variant', type: 'VARIANT', variantOptions: ['Primary', 'Secondary', 'Ghost'] },
-    { name: 'Size', type: 'VARIANT', variantOptions: ['Small', 'Medium', 'Large'] },
-    { name: 'Disabled', type: 'BOOLEAN' },
-    { name: 'Has Icon', type: 'BOOLEAN' },
-    { name: 'Icon', type: 'INSTANCE_SWAP' },
-  ],
-}
-
-const cases: MockNode[] = [
-  {
-    component: 'Button',
-    props: { Label: '提交', Variant: 'Primary', Size: 'Medium', Disabled: false, 'Has Icon': false },
-  },
-  {
-    component: 'Button',
-    props: { Label: '下一步', Variant: 'Secondary', Size: 'Large', Disabled: false, 'Has Icon': true },
-    swaps: { Icon: { component: 'Icon', props: { Name: 'Arrow' } } },
-  },
-  {
-    component: 'Button',
-    props: { Label: '不可用', Variant: 'Ghost', Size: 'Small', Disabled: true, 'Has Icon': false },
-  },
-  {
-    // 故意用一个字典里没有的 variant 值，演示「穷举缺失」会被自检抓到
-    component: 'Button',
-    props: { Label: '危险', Variant: 'Danger', Size: 'Medium', Disabled: false, 'Has Icon': false },
-  },
-]
-
-for (const node of cases) {
-  const calls: AccessorCall[] = []
-  const result = buttonTemplate.render(new MockInstance(node, calls))
-  const probeCalls: AccessorCall[] = []
-  buttonTemplate.render(new MockInstance(node, probeCalls, 0, true))
-  const findings = validate(buttonSchema, calls, probeCalls)
-
-  console.log('─'.repeat(64))
-  console.log('Figma 实例:', JSON.stringify(node.props))
-  console.log('\n' + (result.imports ?? []).join('\n'))
-  console.log(renderToString(result.example))
-  if (findings.length) {
-    console.log('\n自检:')
-    for (const f of findings) console.log(`  [${f.level}] ${f.text}`)
-  }
-  console.log()
-}

package/src/dev/export.ts

@@ -1,28 +0,0 @@
-/**
- * 从当前 registry（generate:registry 扫出来的 templates）生成仓库根目录的 codeconnect.json。
- * 这份文件是给「读代码仓库的 AI / agent」看的映射清单 —— 不需要开 Figma。
- * 跑 `npm run export`。这个引擎仓库自己没有真实映射数据时，产出的就是空列表——
- * 消费方项目要生成自己的 codeconnect.json，得在自己项目里跑同样的 export 逻辑。
- *
- * 插件面板里的「下载 codeconnect.json」是另一份：那份带着 Figma 侧的真实
- * componentKey（绑定过之后），可以覆盖到这里来。
- */
-import { writeFileSync } from 'node:fs'
-import { templates } from '../runtime/registry'
-
-const payload = {
-  namespace: 'simplecodeconnect',
-  generatedFrom: 'figma-mappings/*.figma.ts',
-  label: 'React',
-  mappings: templates.map((t) => ({
-    templateId: t.id,
-    componentName: t.match.componentName,
-    componentKey: t.match.componentKey ?? null,
-    url: t.meta.url,
-    source: t.meta.source,
-    component: t.meta.component,
-  })),
-}
-
-writeFileSync('codeconnect.json', JSON.stringify(payload, null, 2) + '\n', 'utf8')
-console.log(`已写出 codeconnect.json（${payload.mappings.length} 条映射）`)