@pigcloud/skills 1.0.11 → 1.1.2

package/scripts/run-golden-replays.js

@@ -4,18 +4,45 @@ const fs = require('fs');
 const https = require('https');
 const path = require('path');
 
-const suite = require('../skills/references/golden-prompt-suite.js');
-
-const repoRoot = path.join(__dirname, '..');
-const skillsRoot = path.join(repoRoot, 'skills');
-
-function parseArgs(argv) {
-  const options = {
-    provider: process.env.PIG_SKILLS_REPLAY_PROVIDER || 'openai',
-    model: process.env.OPENAI_MODEL || 'gpt-4.1-mini',
-    limit: 0,
-    out: null,
-  };
+const repoRoot = path.join(__dirname, '..');
+const skillsRoot = path.join(repoRoot, 'skills');
+
+function readSkillDirectories() {
+  if (!fs.existsSync(skillsRoot)) {
+    return [];
+  }
+
+  const results = [];
+
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === 'references') {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const skillFile = path.join(fullPath, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+          results.push(fullPath);
+        }
+        walk(fullPath);
+      }
+    }
+  }
+
+  walk(skillsRoot);
+  return results.sort();
+}
+
+function parseArgs(argv) {
+  const options = {
+    provider: process.env.PIG_SKILLS_REPLAY_PROVIDER || 'openai',
+    model: process.env.OPENAI_MODEL || 'gpt-4.1-mini',
+    suite: process.env.PIG_SKILLS_REPLAY_SUITE || 'current',
+    limit: 0,
+    out: null,
+  };
 
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];
@@ -27,17 +54,25 @@ function parseArgs(argv) {
       options.provider = token.slice('--provider='.length);
       continue;
     }
-    if (token === '--model') {
-      options.model = argv[++index];
-      continue;
-    }
-    if (token.startsWith('--model=')) {
-      options.model = token.slice('--model='.length);
-      continue;
-    }
-    if (token === '--limit') {
-      options.limit = Number(argv[++index]) || 0;
-      continue;
+    if (token === '--model') {
+      options.model = argv[++index];
+      continue;
+    }
+    if (token.startsWith('--model=')) {
+      options.model = token.slice('--model='.length);
+      continue;
+    }
+    if (token === '--suite') {
+      options.suite = argv[++index];
+      continue;
+    }
+    if (token.startsWith('--suite=')) {
+      options.suite = token.slice('--suite='.length);
+      continue;
+    }
+    if (token === '--limit') {
+      options.limit = Number(argv[++index]) || 0;
+      continue;
     }
     if (token.startsWith('--limit=')) {
       options.limit = Number(token.slice('--limit='.length)) || 0;
@@ -53,55 +88,49 @@ function parseArgs(argv) {
     }
   }
 
-  return options;
-}
-
-function readSkillCatalog() {
-  return fs.readdirSync(skillsRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && entry.name !== 'references')
-    .map((entry) => {
-      const skillFile = path.join(skillsRoot, entry.name, 'SKILL.md');
-      const content = fs.readFileSync(skillFile, 'utf8');
-      const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-      const frontmatter = frontmatterMatch ? frontmatterMatch[1] : '';
-      const name = (frontmatter.match(/^name:\s*(.+)$/m) || [])[1]?.trim() || entry.name;
-      const description = (frontmatter.match(/^description:\s*(.+)$/m) || [])[1]?.trim() || '';
-      const lifecycleStage = (frontmatter.match(/^lifecycle_stage:\s*(.+)$/m) || [])[1]?.trim() || '';
-      const outputSection = (content.match(/## Output\s+([\s\S]*?)(?:\n## |\n---|$)/) || [])[1] || '';
-      const gatesSection = (content.match(/## Stop Rules\s+([\s\S]*?)(?:\n## |\n---|$)/) || [])[1] || '';
-
-      return {
-        name,
-        description,
-        lifecycleStage,
-        outputs: outputSection
-          .split(/\r?\n/)
-          .map((line) => line.trim().replace(/^-+\s*/, ''))
-          .filter(Boolean)
-          .map((line) => line.replace(/^[*-]\s*/, '')),
-        stopRules: gatesSection
-          .split(/\r?\n/)
-          .map((line) => line.trim().replace(/^-+\s*/, ''))
-          .filter(Boolean),
-      };
-    });
-}
+  return options;
+}
+
+function loadSuite(suiteName) {
+  const currentSuitePath = path.join(repoRoot, 'scripts', 'golden-prompt-suite.current.js');
+  if (fs.existsSync(currentSuitePath)) {
+    return require(currentSuitePath);
+  }
+  throw new Error(`Missing replay suite: ${currentSuitePath}`);
+}
+
+function readSkillCatalog() {
+  return readSkillDirectories()
+    .map((skillDir) => {
+      const skillFile = path.join(skillDir, 'SKILL.md');
+      const content = fs.readFileSync(skillFile, 'utf8');
+      const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      const frontmatter = frontmatterMatch ? frontmatterMatch[1] : '';
+      const name = (frontmatter.match(/^name:\s*(.+)$/m) || [])[1]?.trim() || path.basename(skillDir);
+      const description = (frontmatter.match(/^description:\s*(.+)$/m) || [])[1]?.trim() || '';
+
+      return {
+        name,
+        description,
+      };
+    });
+}
 
 function buildSystemPrompt(catalog) {
-  const lines = [
-    'You are evaluating the pig-skills workflow replay suite.',
-    'Choose the first skill that should handle the prompt.',
-    'Return ONLY valid JSON with these keys:',
-    '{"firstSkill":"...","artifact":"...","stopRule":"...","handoff":"...","notes":"..."}',
-    'Use exact canonical skill names.',
-    'Artifact should be short and reflect the expected work product.',
-    'Do not explain your reasoning outside the JSON object.',
-    '',
-    'Available skills:',
-    ...catalog.map((skill) => `- ${skill.name} | ${skill.description} | outputs: ${skill.outputs.join('; ')} | stop: ${skill.stopRules.join(' | ')}`),
-  ];
-  return lines.join('\n');
-}
+  const lines = [
+    'You are evaluating the pig-skills workflow replay suite.',
+    'Choose the first skill that should handle the prompt.',
+    'Return ONLY valid JSON with these keys:',
+    '{"firstSkill":"...","artifact":"...","stopRule":"...","handoff":"...","notes":"..."}',
+    'Use exact canonical skill names.',
+    'Artifact should be short and reflect the expected work product.',
+    'Do not explain your reasoning outside the JSON object.',
+    '',
+    'Available skills:',
+    ...catalog.map((skill) => `- ${skill.name} | ${skill.description}`),
+  ];
+  return lines.join('\n');
+}
 
 function normalizeText(value) {
   return String(value || '')
@@ -255,11 +284,12 @@ async function evaluateCase(testCase, context) {
   };
 }
 
-async function main() {
-  const options = parseArgs(process.argv.slice(2));
-  const catalog = readSkillCatalog();
-  const systemPrompt = buildSystemPrompt(catalog);
-  const cases = options.limit > 0 ? suite.cases.slice(0, options.limit) : suite.cases;
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const suite = loadSuite(options.suite);
+  const catalog = readSkillCatalog();
+  const systemPrompt = buildSystemPrompt(catalog);
+  const cases = options.limit > 0 ? suite.cases.slice(0, options.limit) : suite.cases;
 
   const context = {
     provider: options.provider,
@@ -267,10 +297,11 @@ async function main() {
     systemPrompt,
   };
 
-  console.log(`# Golden replay run`);
-  console.log(`provider: ${context.provider}`);
-  console.log(`model: ${context.model}`);
-  console.log(`cases: ${cases.length}`);
+  console.log(`# Golden replay run`);
+  console.log(`suite: ${options.suite}`);
+  console.log(`provider: ${context.provider}`);
+  console.log(`model: ${context.model}`);
+  console.log(`cases: ${cases.length}`);
 
   const results = [];
   for (const testCase of cases) {

package/scripts/validate-rules.js

@@ -1,125 +1,128 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-
-const repoRoot = path.join(__dirname, '..');
-const rulesRoot = path.join(repoRoot, 'rules');
-const bundlesPath = path.join(rulesRoot, 'bundles.json');
-const skillProfileMapPath = path.join(rulesRoot, 'skill-profile-map.json');
-const skillsRoot = path.join(repoRoot, 'skills');
-const expectedBundles = ['core', 'workflow', 'product', 'coding', 'docs', 'review', 'overlays'];
-const requiredSections = [
-  '## 默认做法',
-  '## 禁区',
-  '## 检查',
-  '## 回放信号',
-  '## References',
-];
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-function readText(filePath) {
-  return fs.readFileSync(filePath, 'utf8');
-}
-
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
-}
-
-function readSkillDirectories() {
-  return fs.readdirSync(skillsRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && entry.name !== 'references')
-    .map((entry) => entry.name)
-    .sort();
-}
-
-function readSkillProfile(skillName) {
-  const skillFile = path.join(skillsRoot, skillName, 'SKILL.md');
-  const content = readText(skillFile);
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return null;
-  const profileMatch = match[1].match(/^rule_profile:\s*(.+)$/m);
-  return profileMatch ? profileMatch[1].trim() : null;
-}
-
-function verifyBundleFiles(bundleName, bundleConfig) {
-  assert(bundleConfig && typeof bundleConfig === 'object', `${bundleName}: missing bundle config`);
-  assert(typeof bundleConfig.entry === 'string' && bundleConfig.entry.length > 0, `${bundleName}: missing entry`);
-  assert(Array.isArray(bundleConfig.files) && bundleConfig.files.length > 0, `${bundleName}: missing files`);
-
-  const files = new Set(bundleConfig.files);
-  files.add(bundleConfig.entry);
-
-  for (const relativePath of files) {
-    assert(relativePath.startsWith(`${bundleName}/`) || relativePath === `${bundleName}/index.md`, `${bundleName}: file escapes bundle namespace: ${relativePath}`);
-    const filePath = path.join(rulesRoot, relativePath);
-    assert(fs.existsSync(filePath), `${bundleName}: missing file ${relativePath}`);
-    const content = readText(filePath);
-    for (const section of requiredSections) {
-      assert(content.includes(section), `${relativePath}: missing section ${section}`);
-    }
-  }
-
-  if (bundleConfig.profiles) {
-    for (const [profileName, profileConfig] of Object.entries(bundleConfig.profiles)) {
-      assert(typeof profileConfig.entry === 'string' && profileConfig.entry.length > 0, `${bundleName}/${profileName}: missing entry`);
-      assert(Array.isArray(profileConfig.files) && profileConfig.files.length > 0, `${bundleName}/${profileName}: missing files`);
-      const profileFiles = new Set(profileConfig.files);
-      profileFiles.add(profileConfig.entry);
-      for (const relativePath of profileFiles) {
-        assert(relativePath.startsWith(`${bundleName}/`) || relativePath === `${bundleName}/index.md`, `${bundleName}/${profileName}: file escapes bundle namespace: ${relativePath}`);
-        const filePath = path.join(rulesRoot, relativePath);
-        assert(fs.existsSync(filePath), `${bundleName}/${profileName}: missing file ${relativePath}`);
-      }
-    }
-  }
-}
-
-function main() {
-  const bundles = readJson(bundlesPath);
-  const skillProfileMap = readJson(skillProfileMapPath);
-  const skillDirs = readSkillDirectories();
-
-  for (const bundleName of expectedBundles) {
-    assert(Object.prototype.hasOwnProperty.call(bundles, bundleName), `bundles.json missing ${bundleName} bundle`);
-  }
-
-  for (const [bundleName, bundleConfig] of Object.entries(bundles)) {
-    verifyBundleFiles(bundleName, bundleConfig);
-  }
-
-  for (const skillName of skillDirs) {
-    const declaredProfile = readSkillProfile(skillName);
-    assert(declaredProfile, `${skillName}: missing rule_profile`);
-    const mapped = skillProfileMap[skillName];
-    assert(mapped, `${skillName}: missing skill-profile mapping`);
-    assert(mapped.profile === declaredProfile, `${skillName}: profile mismatch (${mapped.profile} != ${declaredProfile})`);
-    assert(expectedBundles.includes(mapped.bundle), `${skillName}: unknown bundle ${mapped.bundle}`);
-    assert(bundles[mapped.bundle].profiles && bundles[mapped.bundle].profiles[mapped.profile], `${skillName}: unknown profile ${mapped.bundle}/${mapped.profile}`);
-  }
-
-  const indexContent = readText(path.join(rulesRoot, 'index.md'));
-  for (const bundleName of expectedBundles) {
-    assert(indexContent.includes(bundleName), `rules/index.md should mention ${bundleName}`);
-  }
-  assert(indexContent.includes('skill-profile-map.json'), 'rules/index.md should mention skill-profile-map.json');
-
-  const loaderContent = readText(path.join(repoRoot, 'bin', 'rules-loader.js'));
-  assert(loaderContent.includes("const CORE_BUNDLE_NAME = 'core'"), 'rules-loader.js should define core bundle');
-  assert(loaderContent.includes("const CORE_PROFILE_NAME = 'core'"), 'rules-loader.js should define core profile');
-  assert(loaderContent.includes("hasCodingSignals"), 'rules-loader.js should define coding detection');
-
-  console.log(`=== Rules validation complete for ${skillDirs.length} skills and ${Object.keys(bundles).length} bundles ===`);
-}
-
-try {
-  main();
-} catch (error) {
-  console.error(error.message);
-  process.exitCode = 1;
-}
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const repoRoot = path.join(__dirname, '..');
+const rulesRoot = path.join(repoRoot, 'rules');
+const stagesPath = path.join(rulesRoot, 'stages.json');
+const skillStageMapPath = path.join(rulesRoot, 'skill-stage-map.json');
+const skillsRoot = path.join(repoRoot, 'skills');
+const expectedStages = ['core', 'discovery', 'design', 'implementation', 'validation', 'delivery', 'shared', 'overlays'];
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function readSkillDirectories() {
+  const results = [];
+
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === 'references') {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const skillFile = path.join(fullPath, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+          results.push(skillFile);
+        }
+        walk(fullPath);
+      }
+    }
+  }
+
+  walk(skillsRoot);
+  return results.sort();
+}
+
+function readSkillName(skillFile) {
+  const content = fs.readFileSync(skillFile, 'utf8');
+  const match = content.match(/^name:\s*(.+)$/m);
+  return match ? match[1].trim() : '';
+}
+
+function verifyStageFiles(stageName, stageConfig) {
+  assert(stageConfig && typeof stageConfig === 'object', `${stageName}: missing stage config`);
+  assert(typeof stageConfig.entry === 'string' && stageConfig.entry.length > 0, `${stageName}: missing entry`);
+  assert(Array.isArray(stageConfig.files) && stageConfig.files.length > 0, `${stageName}: missing files`);
+
+  const files = new Set(stageConfig.files);
+  files.add(stageConfig.entry);
+
+  for (const relativePath of files) {
+    assert(relativePath.startsWith(`${stageName}/`) || stageName === 'overlays' || relativePath === 'core/index.md', `${stageName}: file escapes stage namespace: ${relativePath}`);
+    const filePath = path.join(rulesRoot, relativePath);
+    assert(fs.existsSync(filePath), `${stageName}: missing file ${relativePath}`);
+  }
+
+  if (stageConfig.variants) {
+    for (const [variantName, variantConfig] of Object.entries(stageConfig.variants)) {
+      assert(typeof variantConfig.entry === 'string' && variantConfig.entry.length > 0, `${stageName}/${variantName}: missing entry`);
+      assert(Array.isArray(variantConfig.files) && variantConfig.files.length > 0, `${stageName}/${variantName}: missing files`);
+
+      const variantFiles = new Set(variantConfig.files);
+      variantFiles.add(variantConfig.entry);
+
+      for (const relativePath of variantFiles) {
+        assert(relativePath.startsWith(`${stageName}/`) || relativePath === 'core/index.md' || relativePath === 'overlays/index.md' || relativePath === 'overlays/pig-cloud.md', `${stageName}/${variantName}: file escapes stage namespace: ${relativePath}`);
+        const filePath = path.join(rulesRoot, relativePath);
+        assert(fs.existsSync(filePath), `${stageName}/${variantName}: missing file ${relativePath}`);
+      }
+    }
+  }
+}
+
+function main() {
+  assert(!fs.existsSync(path.join(rulesRoot, 'bundles.json')), 'legacy bundles.json should not exist');
+  assert(!fs.existsSync(path.join(rulesRoot, 'skill-profile-map.json')), 'legacy skill-profile-map.json should not exist');
+
+  const stages = readJson(stagesPath);
+  const skillStageMap = readJson(skillStageMapPath);
+  const skillFiles = readSkillDirectories();
+
+  for (const stageName of expectedStages) {
+    assert(Object.prototype.hasOwnProperty.call(stages, stageName), `stages.json missing ${stageName} stage`);
+  }
+
+  for (const [stageName, stageConfig] of Object.entries(stages)) {
+    verifyStageFiles(stageName, stageConfig);
+  }
+
+  for (const skillFile of skillFiles) {
+    const skillName = readSkillName(skillFile);
+    assert(skillName, `${path.relative(repoRoot, skillFile)}: missing skill name`);
+    const mapped = skillStageMap[skillName];
+    assert(mapped, `${skillName}: missing skill-stage mapping`);
+    assert(expectedStages.includes(mapped.stage), `${skillName}: unknown stage ${mapped.stage}`);
+    assert(stages[mapped.stage], `${skillName}: unknown stage config ${mapped.stage}`);
+  }
+
+  const indexContent = fs.readFileSync(path.join(rulesRoot, 'index.md'), 'utf8');
+  for (const stageName of expectedStages) {
+    assert(indexContent.includes(stageName), `rules/index.md should mention ${stageName}`);
+  }
+  assert(indexContent.includes('skill-stage-map.json'), 'rules/index.md should mention skill-stage-map.json');
+
+  const loaderContent = fs.readFileSync(path.join(repoRoot, 'bin', 'rules-loader.js'), 'utf8');
+  assert(loaderContent.includes('detectRulesStage'), 'rules-loader.js should define detectRulesStage');
+  assert(!loaderContent.includes('hasCodingSignals'), 'rules-loader.js should not use workspace coding detection');
+  assert(!loaderContent.includes('detectRulesBundle'), 'rules-loader.js should not expose bundle-based routing');
+
+  console.log(`=== Rules validation complete for ${skillFiles.length} skills and ${Object.keys(stages).length} stages ===`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/validate-skill-replay-signals.js

@@ -6,63 +6,51 @@ const path = require('path');
 const repoRoot = path.join(__dirname, '..');
 const skillsRoot = path.join(repoRoot, 'skills');
 
-function readSkillDirectories() {
-  return fs.readdirSync(skillsRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && entry.name !== 'references')
-    .map((entry) => entry.name)
-    .sort();
-}
-
-function readSkillFile(skillName) {
-  const skillFile = path.join(skillsRoot, skillName, 'SKILL.md');
-  return fs.readFileSync(skillFile, 'utf8');
-}
-
-function validateSkill(skillName) {
-  const content = readSkillFile(skillName);
-  const lines = content.split(/\r?\n/);
-  const sectionLines = [];
-  let inReplaySection = false;
-
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!inReplaySection) {
-      if (line === '## Replay Signals') {
-        inReplaySection = true;
-      }
-      continue;
-    }
-
-    if (line.startsWith('## ')) {
-      break;
-    }
-
-    if (line.length > 0) {
-      sectionLines.push(line.replace(/^[-*]\s*/, ''));
-    }
-  }
-
-  if (sectionLines.length === 0) {
-    throw new Error(`${skillName}: missing Replay Signals section`);
-  }
-
-  const requiredPrefixes = [
-    'Input signal:',
-    'Output to verify:',
-    'Stop signal:',
-    'Handoff signal:',
-  ];
-
-  const missing = requiredPrefixes.filter((prefix) => !sectionLines.some((line) => line.startsWith(prefix)));
-  if (missing.length > 0) {
-    throw new Error(`${skillName}: Replay Signals missing lines: ${missing.join(' | ')}`);
-  }
-}
-
-function main() {
-  for (const skillName of readSkillDirectories()) {
-    validateSkill(skillName);
-  }
+function readSkillDirectories() {
+  const results = [];
+
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === 'references') {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const skillFile = path.join(fullPath, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+          results.push(fullPath);
+        }
+        walk(fullPath);
+      }
+    }
+  }
+
+  walk(skillsRoot);
+  return results.sort();
+}
+
+function readSkillFile(skillDir) {
+  const skillFile = path.join(skillDir, 'SKILL.md');
+  return fs.readFileSync(skillFile, 'utf8');
+}
+
+function validateSkill(skillDir) {
+  const skillName = path.basename(skillDir);
+  const content = readSkillFile(skillDir);
+  const body = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
+  if (!/##\s+Purpose/.test(body)) {
+    throw new Error(`${skillName}: missing Purpose section`);
+  }
+  if (!/##\s+When to Use/.test(body)) {
+    throw new Error(`${skillName}: missing When to Use section`);
+  }
+}
+
+function main() {
+  for (const skillDir of readSkillDirectories()) {
+    validateSkill(skillDir);
+  }
 
   console.log('=== Replay signal validation complete ===');
 }