@zat-design/sisyphus-scene 1.0.0

package/skills/sisyphus-scene/scripts/install.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const parseArgs = (argv) => {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+    const key = token.slice(2);
+    const value = argv[index + 1];
+    if (!value || value.startsWith('--')) args[key] = true;
+    else {
+      args[key] = value;
+      index += 1;
+    }
+  }
+  return args;
+};
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const source = path.resolve(scriptDirectory, '..');
+const args = parseArgs(process.argv.slice(2));
+const platform = String(args.platform || 'all');
+const scope = String(args.scope || 'user');
+const mode = String(args.mode || 'copy');
+const dryRun = Boolean(args['dry-run']);
+
+if (!['claude', 'codex', 'cursor', 'all'].includes(platform)) {
+  throw new Error(`不支持的平台：${platform}`);
+}
+if (!['user', 'project'].includes(scope)) throw new Error(`不支持的 scope：${scope}`);
+if (!['copy', 'link'].includes(mode)) throw new Error(`不支持的 mode：${mode}`);
+
+const projectRoot = path.resolve(String(args.project || process.cwd()));
+const platformDirectories = {
+  claude: scope === 'user' ? path.join(os.homedir(), '.claude', 'skills') : path.join(projectRoot, '.claude', 'skills'),
+  codex: scope === 'user' ? path.join(os.homedir(), '.agents', 'skills') : path.join(projectRoot, '.agents', 'skills'),
+  cursor: scope === 'user' ? path.join(os.homedir(), '.cursor', 'skills') : path.join(projectRoot, '.cursor', 'skills'),
+};
+
+const selectedPlatforms = platform === 'all' ? Object.keys(platformDirectories) : [platform];
+
+const collectFiles = (directory, relative = '') => {
+  const files = [];
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    if (entry.name === '.DS_Store') continue;
+    const nextRelative = path.join(relative, entry.name);
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...collectFiles(fullPath, nextRelative));
+    else if (entry.isFile()) files.push(nextRelative);
+  }
+  return files.sort();
+};
+
+const fingerprint = (directory) => {
+  const hash = crypto.createHash('sha256');
+  for (const relative of collectFiles(directory)) {
+    hash.update(relative);
+    hash.update(fs.readFileSync(path.join(directory, relative)));
+  }
+  return hash.digest('hex');
+};
+
+const sourceRealPath = fs.realpathSync(source);
+const results = [];
+
+for (const name of selectedPlatforms) {
+  const target = path.join(platformDirectories[name], 'sisyphus-scene');
+  let targetRealPath;
+  try {
+    targetRealPath = fs.realpathSync(target);
+  } catch {
+    targetRealPath = undefined;
+  }
+  if (targetRealPath === sourceRealPath) {
+    results.push({ platform: name, target, action: 'source', fingerprint: fingerprint(source) });
+    continue;
+  }
+  if (!dryRun) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.rmSync(target, { recursive: true, force: true });
+    if (mode === 'link') fs.symlinkSync(source, target, 'dir');
+    else fs.cpSync(source, target, { recursive: true });
+  }
+  results.push({
+    platform: name,
+    target,
+    action: dryRun ? `would-${mode}` : mode,
+    fingerprint: dryRun ? fingerprint(source) : fingerprint(target),
+  });
+}
+
+process.stdout.write(`${JSON.stringify({ source, mode, scope, dryRun, results }, null, 2)}\n`);
+

package/skills/sisyphus-scene/scripts/resolve-versions.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const PACKAGES = [
+  { name: 'antd', major: 6 },
+  { name: '@zat-design/sisyphus-react', major: 4 },
+];
+
+const parseArgs = (argv) => {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+    const key = token.slice(2);
+    const value = argv[index + 1];
+    if (!value || value.startsWith('--')) args[key] = true;
+    else {
+      args[key] = value;
+      index += 1;
+    }
+  }
+  return args;
+};
+
+const parseVersion = (value) => {
+  const match = String(value || '').match(/(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
+  if (!match) return null;
+  return {
+    raw: match[0],
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] || '',
+  };
+};
+
+const compareVersions = (leftValue, rightValue) => {
+  const left = parseVersion(leftValue);
+  const right = parseVersion(rightValue);
+  if (!left || !right) return 0;
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) return left[key] - right[key];
+  }
+  if (!left.prerelease && right.prerelease) return 1;
+  if (left.prerelease && !right.prerelease) return -1;
+  return left.prerelease.localeCompare(right.prerelease, undefined, { numeric: true });
+};
+
+const readPackageJson = (root) => {
+  const packagePath = path.join(root, 'package.json');
+  if (!fs.existsSync(packagePath)) throw new Error(`未找到 package.json：${packagePath}`);
+  return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+};
+
+const getDeclaredVersion = (packageJson, packageName) => {
+  const sections = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+  for (const section of sections) {
+    const value = packageJson[section]?.[packageName];
+    if (value) return value;
+  }
+  return undefined;
+};
+
+const getPackageLockVersion = (root, packageName) => {
+  const packageLockPath = path.join(root, 'package-lock.json');
+  if (!fs.existsSync(packageLockPath)) return undefined;
+  try {
+    const lock = JSON.parse(fs.readFileSync(packageLockPath, 'utf8'));
+    return lock.packages?.[`node_modules/${packageName}`]?.version;
+  } catch {
+    return undefined;
+  }
+};
+
+const getYarnLockVersion = (root, packageName, declared) => {
+  const yarnLockPath = path.join(root, 'yarn.lock');
+  if (!fs.existsSync(yarnLockPath)) return undefined;
+  const content = fs.readFileSync(yarnLockPath, 'utf8');
+  const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escapedSelector = declared
+    ? `${escaped}@${String(declared).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`
+    : undefined;
+  for (const block of content.split(/\n{2,}/)) {
+    const header = block.split('\n', 1)[0];
+    if (escapedSelector && !new RegExp(`(?:^|["',\\s])${escapedSelector}(?:["',:]|$)`).test(header)) continue;
+    if (!new RegExp(`(?:^|["',\\s])${escaped}@`).test(header)) continue;
+    const version = block.match(/^\s{2}version\s+["']?([^"'\n]+)["']?$/m);
+    if (version) return version[1];
+  }
+  return undefined;
+};
+
+const getPnpmLockVersion = (root, packageName) => {
+  const pnpmLockPath = path.join(root, 'pnpm-lock.yaml');
+  if (!fs.existsSync(pnpmLockPath)) return undefined;
+  const content = fs.readFileSync(pnpmLockPath, 'utf8');
+  const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const patterns = [
+    new RegExp(`(?:^|\\n)\\s{2,}['"]?${escaped}@([^:'"\\s]+)`, 'm'),
+    new RegExp(`(?:^|\\n)\\s{2,}/?${escaped}/([^:\\s]+):`, 'm'),
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) return match[1];
+  }
+  return undefined;
+};
+
+const getResolvedVersions = (root, packageName, declared) => {
+  const values = {
+    packageLock: getPackageLockVersion(root, packageName),
+    yarnLock: getYarnLockVersion(root, packageName, declared),
+    pnpmLock: getPnpmLockVersion(root, packageName),
+  };
+  const present = Object.values(values).filter(Boolean);
+  const unique = [...new Set(present)];
+  return {
+    values,
+    resolved: unique.length === 1 ? unique[0] : undefined,
+    conflict: unique.length > 1,
+  };
+};
+
+const queryVersions = (root, packageName) => {
+  const output = execFileSync('npm', ['view', packageName, 'versions', '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  const parsed = JSON.parse(output);
+  return Array.isArray(parsed) ? parsed : [parsed];
+};
+
+const chooseLatest = (versions, major, channel) =>
+  versions
+    .filter((version) => {
+      const parsed = parseVersion(version);
+      if (!parsed || parsed.major !== major) return false;
+      return channel === 'beta' || !parsed.prerelease;
+    })
+    .sort(compareVersions)
+    .at(-1);
+
+const evaluateStatus = ({ declared, resolved, latest, major, lockConflict }) => {
+  if (lockConflict) return 'lock-conflict';
+  const active = parseVersion(resolved || declared);
+  if (!active) return 'unknown';
+  if (active.major !== major) return 'unsupported-major';
+  if (!latest) return 'unknown';
+  return compareVersions(active.raw, latest) === 0 ? 'ok' : 'outdated';
+};
+
+const args = parseArgs(process.argv.slice(2));
+const root = path.resolve(String(args.root || process.cwd()));
+const channel = String(args.channel || 'stable');
+if (!['stable', 'beta'].includes(channel)) throw new Error(`不支持的 channel：${channel}`);
+const offline = Boolean(args.offline);
+const packageJson = readPackageJson(root);
+
+const results = PACKAGES.map(({ name, major }) => {
+  const declared = getDeclaredVersion(packageJson, name);
+  const lockResolution = getResolvedVersions(root, name, declared);
+  let versions = [];
+  let registryError;
+  if (!offline) {
+    try {
+      versions = queryVersions(root, name);
+    } catch (error) {
+      registryError = error.stderr?.trim() || error.message;
+    }
+  }
+  const latest = chooseLatest(versions, major, channel);
+  return {
+    name,
+    requiredRange: `>=${major} <${major + 1}`,
+    channel,
+    declared,
+    resolved: lockResolution.resolved,
+    resolvedVersions: lockResolution.values,
+    latest,
+    status: evaluateStatus({
+      declared,
+      resolved: lockResolution.resolved,
+      latest,
+      major,
+      lockConflict: lockResolution.conflict,
+    }),
+    ...(registryError ? { registryError } : {}),
+  };
+});
+
+const report = {
+  root,
+  channel,
+  ok: results.every((item) => item.status === 'ok'),
+  packages: results,
+};
+
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+if (!report.ok) process.exitCode = 2;

package/skills/sisyphus-scene/scripts/validate-scaffold.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const parseArgs = (argv) => {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) continue;
+    const key = token.slice(2);
+    const value = argv[index + 1];
+    if (!value || value.startsWith('--')) args[key] = true;
+    else {
+      args[key] = value;
+      index += 1;
+    }
+  }
+  return args;
+};
+
+const isWithin = (parent, child) => {
+  const relative = path.relative(parent, child);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+};
+
+const readDecisions = (filePath) => {
+  const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  return Array.isArray(parsed) ? parsed : parsed.decisions || [];
+};
+
+const extractNamedImports = (content, source) => {
+  const escaped = source.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const regex = new RegExp(`import\\s+(?:type\\s+)?\\{([^}]+)\\}\\s+from\\s+['"]${escaped}['"]`, 'g');
+  const names = [];
+  for (const match of content.matchAll(regex)) {
+    for (const token of match[1].split(',')) {
+      const name = token.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0].trim();
+      if (name) names.push(name);
+    }
+  }
+  return names;
+};
+
+const args = parseArgs(process.argv.slice(2));
+const root = path.resolve(String(args.root || process.cwd()));
+if (!args.files) throw new Error('必须传入 --files <逗号分隔文件>');
+if (!args.decisions) throw new Error('必须传入 --decisions <ComponentDecision JSON>');
+
+const files = String(args.files)
+  .split(',')
+  .map((item) => path.resolve(root, item.trim()))
+  .filter(Boolean);
+const decisionsPath = path.resolve(root, String(args.decisions));
+const decisions = readDecisions(decisionsPath);
+const errors = [];
+const warnings = [];
+const checks = [];
+
+const addError = (file, rule, message) => errors.push({ file, rule, message });
+const addWarning = (file, rule, message) => warnings.push({ file, rule, message });
+
+for (const decision of decisions) {
+  if (!decision.requirementId || !decision.requirement) {
+    addError(decisionsPath, 'decision-schema', '每条 decision 必须包含 requirementId 和 requirement');
+  }
+  if (['unverified', 'unresolved'].includes(decision.status) || decision.source === 'unresolved') {
+    addError(decisionsPath, 'unresolved-capability', `能力未解决：${decision.requirement || decision.requirementId}`);
+  }
+  if (decision.source === 'sisyphus' && (!decision.apiEvidence || !decision.demoEvidence)) {
+    addError(decisionsPath, 'sisyphus-evidence', `Sisyphus 决策缺少 API 或 demo 证据：${decision.requirement}`);
+  }
+  if (
+    decision.source === 'antd' &&
+    (!decision.apiEvidence || !decision.demoEvidence || !decision.fallbackReason)
+  ) {
+    addError(decisionsPath, 'antd-fallback-evidence', `Ant Design fallback 证据不完整：${decision.requirement}`);
+  }
+  if (decision.source === 'project' && (!decision.apiEvidence || !decision.demoEvidence)) {
+    addError(decisionsPath, 'project-evidence', `项目组件决策缺少源码或调用示例：${decision.requirement}`);
+  }
+}
+
+for (const filePath of files) {
+  if (!isWithin(root, filePath)) {
+    addError(filePath, 'scope', '生成文件位于项目根目录外');
+    continue;
+  }
+  if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+    addError(filePath, 'exists', '生成文件不存在');
+    continue;
+  }
+  const content = fs.readFileSync(filePath, 'utf8');
+  const relative = path.relative(root, filePath);
+
+  const forbiddenPatterns = [
+    { rule: 'antd4', pattern: /from\s+['"]antd4['"]/, message: '禁止使用 antd4' },
+    { rule: 'ts-nocheck', pattern: /@ts-nocheck/, message: '禁止使用 @ts-nocheck' },
+    { rule: 'numbered-separator', pattern: /\/\/\s*─+\s*\d/, message: '禁止序号分隔注释' },
+    { rule: 'empty-catch', pattern: /catch\s*\([^)]*\)\s*\{\s*\}/, message: '禁止空 catch' },
+  ];
+  for (const item of forbiddenPatterns) {
+    if (item.pattern.test(content)) addError(relative, item.rule, item.message);
+  }
+
+  if (/\bProForm\b/.test(content) && /<Form\.Item\b/.test(content)) {
+    addError(relative, 'proform-form-item', 'ProForm 中混入 Form.Item，必须提供明确组件证据或改用配置列');
+  }
+
+  const sisyphusImports = extractNamedImports(content, '@zat-design/sisyphus-react').filter((name) =>
+    /^Pro[A-Z]/.test(name) && !/(Type|Props)$/.test(name),
+  );
+  for (const component of sisyphusImports) {
+    const decision = decisions.find(
+      (item) => item.source === 'sisyphus' && item.component === component && item.status !== 'unverified',
+    );
+    if (!decision) {
+      addError(relative, 'sisyphus-component-decision', `组件 ${component} 缺少 ComponentDecision 证据`);
+    }
+  }
+
+  const structuralAntdComponents = new Set(['Tabs', 'Modal', 'Drawer', 'Table', 'Steps', 'Collapse']);
+  const antdImports = extractNamedImports(content, 'antd').filter((name) => structuralAntdComponents.has(name));
+  for (const component of antdImports) {
+    const decision = decisions.find(
+      (item) =>
+        item.source === 'antd' &&
+        item.component === component &&
+        item.fallbackReason &&
+        item.apiEvidence &&
+        item.demoEvidence,
+    );
+    if (!decision) {
+      addError(relative, 'antd-fallback-decision', `结构组件 ${component} 缺少完整 fallback 证据`);
+    }
+  }
+
+  const routerImports = ['@umijs/max', 'react-router-dom', 'next/navigation'].filter((source) =>
+    new RegExp(`from\\s+['"]${source.replace('/', '\\/')}['"]`).test(content),
+  );
+  if (routerImports.length > 0 && !decisions.some((item) => /导航|路由|返回|跳转/.test(item.requirement))) {
+    addWarning(relative, 'router-without-decision', `存在路由 import，但没有导航能力决策：${routerImports.join(', ')}`);
+  }
+
+  checks.push({ file: relative, status: 'checked' });
+}
+
+const report = {
+  root,
+  ok: errors.length === 0,
+  checks,
+  errors,
+  warnings,
+};
+
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+if (!report.ok) process.exitCode = 1;

package/skills/sisyphus-scene/scripts/validate-skill.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const skillRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const skillPath = path.join(skillRoot, 'SKILL.md');
+const content = fs.readFileSync(skillPath, 'utf8');
+const errors = [];
+
+const frontmatter = content.match(/^---\n([\s\S]*?)\n---\n/);
+if (!frontmatter) errors.push('SKILL.md 缺少有效 YAML frontmatter');
+else {
+  const keys = [...frontmatter[1].matchAll(/^([A-Za-z0-9_-]+):/gm)].map((match) => match[1]);
+  for (const required of ['name', 'description']) {
+    if (!keys.includes(required)) errors.push(`frontmatter 缺少 ${required}`);
+  }
+  const extra = keys.filter((key) => !['name', 'description'].includes(key));
+  if (extra.length > 0) errors.push(`frontmatter 包含非共享字段：${extra.join(', ')}`);
+}
+
+if (content.split('\n').length > 500) errors.push('SKILL.md 超过 500 行');
+
+for (const match of content.matchAll(/`((?:references|assets|scripts)\/[^`]+)`/g)) {
+  const resource = match[1].replace(/\s+.*$/, '');
+  if (resource.includes('<')) continue;
+  if (!fs.existsSync(path.join(skillRoot, resource))) errors.push(`引用资源不存在：${resource}`);
+}
+
+for (const required of [
+  'references/workflow.md',
+  'references/scene-model.md',
+  'references/integration-contracts.md',
+  'references/validation-rules.md',
+  'assets/templates/scene-registry.json',
+  'agents/openai.yaml',
+]) {
+  if (!fs.existsSync(path.join(skillRoot, required))) errors.push(`缺少资源：${required}`);
+}
+
+JSON.parse(fs.readFileSync(path.join(skillRoot, 'assets/templates/scene-registry.json'), 'utf8'));
+
+const report = { skillRoot, ok: errors.length === 0, errors };
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+if (!report.ok) process.exitCode = 1;
+