@pigcloud/skills 1.0.0

package/bin/postinstall.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const cliPath = path.join(__dirname, 'cli.js');
+const autoSyncDisabled = ['1', 'true', 'yes'].includes(String(process.env.PIG_SKILLS_SKIP_AUTO_SYNC || '').toLowerCase());
+
+function print(message) {
+  process.stdout.write(`${message}\n`);
+}
+
+function warn(message) {
+  process.stderr.write(`${message}\n`);
+}
+
+function syncCodexSkills() {
+  const result = spawnSync(process.execPath, [cliPath, 'auto'], {
+    stdio: 'pipe',
+    env: {
+      ...process.env,
+      PIG_SKILLS_POSTINSTALL: '1'
+    }
+  });
+
+  if (result.error) {
+    return { ok: false, output: result.error.message };
+  }
+
+  const output = [result.stdout, result.stderr]
+    .filter(Boolean)
+    .map(buffer => buffer.toString('utf8').trim())
+    .filter(Boolean)
+    .join('\n');
+
+  return {
+    ok: result.status === 0,
+    output: output || `exit code ${result.status ?? 0}`
+  };
+}
+
+print('Pig Cloud Skills installed.');
+
+if (autoSyncDisabled) {
+  print('Auto-sync skipped because PIG_SKILLS_SKIP_AUTO_SYNC is set.');
+  print('Run `pig-skills auto` later to sync skills for the detected client(s).');
+  process.exit(0);
+}
+
+const result = syncCodexSkills();
+
+if (result.ok) {
+  print('Auto-sync complete: skills are installed for the detected client(s).');
+  process.exit(0);
+}
+
+warn('Auto-sync could not complete during install.');
+warn(result.output);
+warn('Run `pig-skills auto` after install to finish syncing manually.');
+process.exit(0);

package/bin/rules-loader.js

@@ -0,0 +1,484 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+const RULES_ROOT = path.join(PACKAGE_ROOT, 'rules');
+const REGISTRY_PATH = path.join(RULES_ROOT, 'bundles.json');
+const SKILL_PROFILE_MAP_PATH = path.join(RULES_ROOT, 'skill-profile-map.json');
+const SKILLS_ROOT = path.join(PACKAGE_ROOT, 'skills');
+const CORE_BUNDLE_NAME = 'core';
+const CORE_PROFILE_NAME = 'core';
+const REVIEW_BUNDLE_NAME = 'review';
+
+function readRegistry() {
+  return JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+}
+
+function readSkillProfileMap() {
+  return JSON.parse(fs.readFileSync(SKILL_PROFILE_MAP_PATH, 'utf8'));
+}
+
+function readSkillRuleProfile(skillName) {
+  const skillFile = path.join(SKILLS_ROOT, skillName, 'SKILL.md');
+  if (!fs.existsSync(skillFile)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(skillFile, 'utf8');
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+
+  const profileMatch = frontmatterMatch[1].match(/^rule_profile:\s*(.+)$/m);
+  return profileMatch ? profileMatch[1].trim() : null;
+}
+
+function readSkillRuleBundle(skillName) {
+  const skillProfileMap = readSkillProfileMap();
+  const mapped = skillProfileMap[skillName];
+  if (mapped && mapped.bundle) {
+    return mapped.bundle;
+  }
+
+  const profile = readSkillRuleProfile(skillName);
+  if (!profile || profile === CORE_PROFILE_NAME) {
+    return CORE_BUNDLE_NAME;
+  }
+
+  return findBundleByProfile(readRegistry(), profile);
+}
+
+function combineLayers(layers, meta = {}) {
+  const flattenedFiles = [];
+  const seen = new Set();
+
+  for (const layer of layers) {
+    for (const file of layer.files || []) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      flattenedFiles.push(file);
+    }
+  }
+
+  const primary = meta.baseLayer || layers[layers.length - 1] || layers[0] || null;
+  return {
+    bundle: meta.bundle || (primary ? primary.bundle : CORE_BUNDLE_NAME),
+    profile: meta.profile || (primary ? primary.profile : null),
+    skill: meta.skill || null,
+    source: meta.source || 'workspace detection',
+    entry: meta.entry || (primary ? primary.entry : 'core/index.md'),
+    files: flattenedFiles,
+    description: primary ? primary.description : 'Baseline rules',
+    layers
+  };
+}
+
+function getLayer(registry, bundleName, profileName = '') {
+  const bundle = registry[bundleName];
+  if (!bundle) return null;
+
+  const profile = profileName && bundle.profiles && bundle.profiles[profileName]
+    ? profileName
+    : (bundle.profiles && bundle.profiles[CORE_PROFILE_NAME] ? CORE_PROFILE_NAME : '');
+  const selected = profile ? bundle.profiles[profile] : bundle;
+
+  if (!selected) return null;
+
+  return {
+    bundle: bundleName,
+    profile: profile || null,
+    entry: selected.entry,
+    files: selected.files,
+    description: selected.description || bundle.description
+  };
+}
+
+function listSkillDirectories() {
+  if (!fs.existsSync(SKILLS_ROOT)) {
+    return [];
+  }
+
+  return fs.readdirSync(SKILLS_ROOT, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name !== 'references')
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function shouldValidateSkillProfiles() {
+  const skip = String(process.env.PIG_SKILLS_SKIP_RULE_PROFILE_VALIDATION || '').trim().toLowerCase();
+  if (['1', 'true', 'yes'].includes(skip)) {
+    return false;
+  }
+
+  const explicit = String(process.env.PIG_SKILLS_VALIDATE_RULE_PROFILES || '').trim().toLowerCase();
+  if (['1', 'true', 'yes'].includes(explicit)) {
+    return true;
+  }
+
+  return process.env.NODE_ENV !== 'production';
+}
+
+function validateSkillProfileConsistency() {
+  const registry = readRegistry();
+  const skillProfileMap = readSkillProfileMap();
+  const skillDirs = listSkillDirectories();
+  const issues = [];
+
+  const mappedSkills = Object.keys(skillProfileMap).sort();
+  for (const skillName of skillDirs) {
+    if (!skillProfileMap[skillName]) {
+      issues.push(`Missing mapping for skill: ${skillName}`);
+      continue;
+    }
+
+    const declaredProfile = readSkillRuleProfile(skillName);
+    if (!declaredProfile) {
+      issues.push(`Missing rule_profile declaration for skill: ${skillName}`);
+      continue;
+    }
+
+    const mappedProfile = skillProfileMap[skillName].profile || CORE_PROFILE_NAME;
+    if (declaredProfile !== mappedProfile) {
+      issues.push(`Profile mismatch for ${skillName}: skill=${declaredProfile}, map=${mappedProfile}`);
+    }
+
+    const mappedBundle = skillProfileMap[skillName].bundle || CORE_BUNDLE_NAME;
+    const bundle = registry[mappedBundle];
+    if (!bundle) {
+      issues.push(`Unknown bundle mapped for ${skillName}: ${mappedBundle}`);
+      continue;
+    }
+
+    if (!bundle.profiles || !bundle.profiles[mappedProfile]) {
+      issues.push(`Unknown profile mapped for ${skillName}: ${mappedBundle}/${mappedProfile}`);
+    }
+  }
+
+  for (const mappedSkill of mappedSkills) {
+    if (!skillDirs.includes(mappedSkill)) {
+      issues.push(`Mapping exists for missing skill directory: ${mappedSkill}`);
+    }
+  }
+
+  if (issues.length > 0) {
+    const error = new Error(`Rule profile consistency check failed:\n- ${issues.join('\n- ')}`);
+    error.issues = issues;
+    throw error;
+  }
+
+  return {
+    skillCount: skillDirs.length,
+    mappedSkillCount: mappedSkills.length
+  };
+}
+
+function findBundleByProfile(registry, profileName) {
+  if (!profileName || profileName === CORE_PROFILE_NAME) {
+    return registry[CORE_BUNDLE_NAME] ? CORE_BUNDLE_NAME : Object.keys(registry)[0] || CORE_BUNDLE_NAME;
+  }
+
+  for (const [bundleName, bundleConfig] of Object.entries(registry)) {
+    if (bundleConfig && bundleConfig.profiles && bundleConfig.profiles[profileName]) {
+      return bundleName;
+    }
+  }
+
+  return null;
+}
+
+function existsInRoot(cwd, relativePath) {
+  return fs.existsSync(path.join(cwd, relativePath));
+}
+
+function normalizeChangedFiles(changedFilesInput) {
+  if (!changedFilesInput) {
+    return [];
+  }
+
+  const items = Array.isArray(changedFilesInput)
+    ? changedFilesInput
+    : String(changedFilesInput)
+        .split(/[\r\n,]+/)
+        .map((item) => item.trim());
+
+  return [...new Set(items.filter(Boolean))];
+}
+
+function hasChangedFile(changedFiles, matcher) {
+  return changedFiles.some((filePath) => matcher(filePath.replace(/\\/g, '/')));
+}
+
+function hasCodingSignals(cwd) {
+  const packageJsonPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (pkg && typeof pkg === 'object') {
+        const hasScripts = pkg.scripts && typeof pkg.scripts === 'object' && Object.keys(pkg.scripts).length > 0;
+        const hasDeps = (pkg.dependencies && Object.keys(pkg.dependencies).length > 0)
+          || (pkg.devDependencies && Object.keys(pkg.devDependencies).length > 0);
+        if (hasScripts || hasDeps) {
+          return true;
+        }
+      }
+    } catch {
+      // Ignore malformed package.json and fall back to file heuristics.
+    }
+  }
+
+  return [
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'mvnw',
+    'gradlew',
+    'src',
+    'src/main/java',
+    'src/main/resources',
+    'README.md',
+    'README.en.md'
+  ].some((hint) => existsInRoot(cwd, hint));
+}
+
+function hasJavaSignals(cwd) {
+  return [
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'mvnw',
+    'gradlew',
+    'src/main/java',
+    'src/main/resources',
+    'src/test/java'
+  ].some((hint) => existsInRoot(cwd, hint));
+}
+
+function hasVueSignals(cwd) {
+  return [
+    'frontend',
+    'frontend/src',
+    'src/App.vue',
+    'src/main.ts',
+    'src/main.js',
+    'src/components',
+    'src/views',
+    'vite.config.ts',
+    'vite.config.js',
+    'vue.config.js'
+  ].some((hint) => existsInRoot(cwd, hint));
+}
+
+function hasTypeScriptSignals(cwd) {
+  return [
+    'tsconfig.json',
+    'tsconfig.app.json',
+    'tsconfig.node.json',
+    'src',
+    'frontend/src',
+    'src/main.ts',
+    'src/env.d.ts',
+    'frontend/tsconfig.json'
+  ].some((hint) => existsInRoot(cwd, hint));
+}
+
+function detectReviewAutoOverlayProfiles(cwd, registry, changedFilesInput = []) {
+  const profiles = [];
+  const reviewBundle = registry[REVIEW_BUNDLE_NAME] || {};
+  const reviewProfiles = reviewBundle.profiles || {};
+  const changedFiles = normalizeChangedFiles(changedFilesInput);
+
+  if (changedFiles.length > 0) {
+    if (reviewProfiles['code-java'] && (
+      hasChangedFile(changedFiles, (filePath) => /\.(java|kt|xml)$/i.test(filePath))
+      || hasChangedFile(changedFiles, (filePath) => /(^|\/)(pom\.xml|build\.gradle(\.kts)?|mvnw|gradlew)$/i.test(filePath))
+      || hasChangedFile(changedFiles, (filePath) => /(^|\/)(src\/main\/java|src\/test\/java)(\/|$)/i.test(filePath))
+    )) {
+      profiles.push('code-java');
+    }
+
+    if (reviewProfiles['code-vue'] && (
+      hasChangedFile(changedFiles, (filePath) => /\.vue$/i.test(filePath))
+      || hasChangedFile(changedFiles, (filePath) => /(^|\/)(src\/main\.(ts|js)|src\/App\.vue|src\/components|src\/views|frontend\/)/i.test(filePath))
+      || hasChangedFile(changedFiles, (filePath) => /(^|\/)(vite\.config\.(ts|js)|vue\.config\.js)$/i.test(filePath))
+    )) {
+      profiles.push('code-vue');
+    }
+
+    if (reviewProfiles['code-ts'] && (
+      hasChangedFile(changedFiles, (filePath) => /\.(ts|tsx|d\.ts)$/i.test(filePath))
+      || hasChangedFile(changedFiles, (filePath) => /(^|\/)(tsconfig(\.[^.]+)?\.json|vite\.config\.ts|eslint\.config\.ts|src\/env\.d\.ts)$/i.test(filePath))
+      || hasChangedFile(changedFiles, (filePath) => /(^|\/)(src\/store|src\/stores|src\/state|frontend\/src\/store|frontend\/src\/stores|frontend\/src\/state)(\/|$)/i.test(filePath))
+    )) {
+      profiles.push('code-ts');
+    }
+
+    return profiles;
+  }
+
+  if (hasJavaSignals(cwd) && reviewProfiles['code-java']) {
+    profiles.push('code-java');
+  }
+
+  if (hasVueSignals(cwd) && reviewProfiles['code-vue']) {
+    profiles.push('code-vue');
+  }
+
+  if (hasTypeScriptSignals(cwd) && reviewProfiles['code-ts']) {
+    profiles.push('code-ts');
+  }
+
+  return profiles;
+}
+
+function parseBundleOverride(override) {
+  if (!override) {
+    return { bundle: '', profile: '' };
+  }
+
+  if (override.includes(':')) {
+    const [bundle, profile] = override.split(':', 2);
+    return { bundle, profile };
+  }
+
+  if (override.includes('/')) {
+    const [bundle, profile] = override.split('/', 2);
+    return { bundle, profile };
+  }
+
+  return { bundle: override, profile: '' };
+}
+
+function detectRulesBundle(cwd = process.cwd(), changedFilesInput = []) {
+  const registry = readRegistry();
+  const skillProfileMap = readSkillProfileMap();
+  const override = String(process.env.PIG_SKILLS_RULE_BUNDLE || process.env.PIG_SKILLS_RULES_BUNDLE || '').trim();
+  const profileOverride = String(process.env.PIG_SKILLS_RULE_PROFILE || '').trim();
+  const skillOverride = String(process.env.PIG_SKILLS_RULE_SKILL || '').trim();
+  const overlayOverride = String(process.env.PIG_SKILLS_RULE_OVERLAY || '').trim();
+  const changedFiles = normalizeChangedFiles(
+    changedFilesInput.length > 0
+      ? changedFilesInput
+      : process.env.PIG_SKILLS_CHANGED_FILES || ''
+  );
+
+  if (shouldValidateSkillProfiles()) {
+    validateSkillProfileConsistency();
+  }
+
+  function resolveBundleSelection(bundleName, profileName = '') {
+    const layers = [];
+    let baseLayer = null;
+    const seenLayers = new Set();
+
+    function addLayer(bundle, profile, markAsBase = false) {
+      const layer = getLayer(registry, bundle, profile);
+      if (!layer) return null;
+      const key = `${layer.bundle}:${layer.profile || ''}`;
+      if (seenLayers.has(key)) {
+        if (markAsBase) baseLayer = layer;
+        return layer;
+      }
+      seenLayers.add(key);
+      layers.push(layer);
+      if (markAsBase) baseLayer = layer;
+      return layer;
+    }
+
+    if (bundleName === CORE_BUNDLE_NAME) {
+      addLayer(CORE_BUNDLE_NAME, CORE_PROFILE_NAME, true);
+    } else {
+      addLayer(CORE_BUNDLE_NAME, CORE_PROFILE_NAME);
+      addLayer(bundleName, profileName, true);
+    }
+
+    if (bundleName === REVIEW_BUNDLE_NAME) {
+      for (const autoProfile of detectReviewAutoOverlayProfiles(cwd, registry, changedFiles)) {
+        addLayer(REVIEW_BUNDLE_NAME, autoProfile);
+      }
+    }
+
+    if (overlayOverride && registry[overlayOverride]) {
+      const overlayProfile = profileOverride && registry[overlayOverride].profiles && registry[overlayOverride].profiles[profileOverride]
+        ? profileOverride
+        : (registry[overlayOverride].profiles && registry[overlayOverride].profiles[CORE_PROFILE_NAME] ? CORE_PROFILE_NAME : '');
+      addLayer(overlayOverride, overlayProfile);
+    }
+
+    if (layers.length === 0) return null;
+    return combineLayers(layers, {
+      bundle: bundleName,
+      profile: profileName || null,
+      baseLayer,
+      source: 'environment override'
+    });
+  }
+
+  if (override) {
+    const parsed = parseBundleOverride(override);
+    if (registry[parsed.bundle]) {
+      const resolved = resolveBundleSelection(parsed.bundle, profileOverride || parsed.profile || '');
+      if (resolved) return resolved;
+    }
+  }
+
+  if (skillOverride) {
+    const mapped = skillProfileMap[skillOverride] || {};
+    const declaredProfile = readSkillRuleProfile(skillOverride);
+    const selectedProfile = profileOverride || mapped.profile || declaredProfile || '';
+    const selectedBundle = mapped.bundle || readSkillRuleBundle(skillOverride) || findBundleByProfile(registry, selectedProfile);
+    const resolved = selectedBundle ? resolveBundleSelection(selectedBundle, selectedProfile) : null;
+    if (resolved) {
+      return {
+        ...resolved,
+        skill: skillOverride,
+        source: declaredProfile ? 'skill declaration' : 'skill mapping'
+      };
+    }
+  }
+
+  const bundle = hasCodingSignals(cwd) ? 'coding' : CORE_BUNDLE_NAME;
+  const bundleConfig = registry[bundle];
+  const profileName = bundle === CORE_BUNDLE_NAME
+    ? CORE_PROFILE_NAME
+    : (profileOverride && bundleConfig && bundleConfig.profiles && bundleConfig.profiles[profileOverride]
+      ? profileOverride
+      : (bundleConfig && bundleConfig.profiles && bundleConfig.profiles.analysis ? 'analysis' : 'core'));
+  const selection = resolveBundleSelection(bundle, profileName || '');
+
+  if (!selection) {
+    return combineLayers(
+      [getLayer(registry, CORE_BUNDLE_NAME, CORE_PROFILE_NAME)].filter(Boolean),
+      {
+        bundle: CORE_BUNDLE_NAME,
+        profile: CORE_PROFILE_NAME,
+        skill: skillOverride || null,
+        source: 'workspace detection'
+      }
+    );
+  }
+
+  return {
+    ...selection,
+    skill: skillOverride || null,
+    source: 'workspace detection'
+  };
+}
+
+if (require.main === module) {
+  const cwd = process.argv[2] ? path.resolve(process.argv[2]) : process.cwd();
+  process.stdout.write(`${JSON.stringify(detectRulesBundle(cwd), null, 2)}\n`);
+}
+
+module.exports = {
+  detectRulesBundle,
+  readRegistry,
+  readSkillProfileMap,
+  readSkillRuleProfile,
+  readSkillRuleBundle,
+  validateSkillProfileConsistency,
+  shouldValidateSkillProfiles,
+  findBundleByProfile
+};

package/bin/runtime-bootstrap.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const NPM_CANDIDATES = process.platform === 'win32'
+  ? [
+      path.join(process.env.ProgramFiles || 'C:\\Program Files', 'nodejs', 'npm.cmd'),
+      path.join(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'nodejs', 'npm.cmd'),
+      path.join(process.env.LocalAppData || '', 'Programs', 'nodejs', 'npm.cmd'),
+      path.join(process.env.LocalAppData || '', 'Microsoft', 'WinGet', 'Links', 'npm.cmd')
+    ]
+  : [];
+
+function commandAvailable(command) {
+  const result = spawnSync(command, ['--version'], { stdio: 'ignore' });
+  return !result.error && result.status === 0;
+}
+
+function findInstalledNpm() {
+  for (const candidate of NPM_CANDIDATES) {
+    if (candidate && fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function refreshPathFromNpm(npmPath) {
+  if (!npmPath) return;
+  const npmDir = path.dirname(npmPath);
+  const currentPath = String(process.env.PATH || '');
+  const parts = currentPath.split(path.delimiter).filter(Boolean);
+  if (!parts.some((part) => part.toLowerCase() === npmDir.toLowerCase())) {
+    process.env.PATH = [npmDir, ...parts].join(path.delimiter);
+  }
+}
+
+function installNodeJsWithWinget() {
+  const args = [
+    'install',
+    '--id',
+    'OpenJS.NodeJS.LTS',
+    '-e',
+    '--source',
+    'winget',
+    '--accept-package-agreements',
+    '--accept-source-agreements',
+    '--silent',
+    '--disable-interactivity'
+  ];
+
+  const result = spawnSync('winget', args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  if (result.error) {
+    throw new Error(`Failed to launch winget: ${result.error.message}`);
+  }
+
+  if (result.status !== 0) {
+    const message = [result.stdout, result.stderr]
+      .filter(Boolean)
+      .map((text) => String(text).trim())
+      .filter(Boolean)
+      .join('\n');
+    throw new Error(message || `winget exited with code ${result.status}`);
+  }
+}
+
+async function ensureNpmRuntime(options = {}) {
+  const skip = ['1', 'true', 'yes'].includes(String(process.env.PIG_SKILLS_SKIP_RUNTIME_BOOTSTRAP || '').toLowerCase());
+  if (skip) {
+    return { installed: false, skipped: true, npmPath: commandAvailable('npm') ? 'npm' : null };
+  }
+
+  if (commandAvailable('npm')) {
+    return { installed: false, skipped: false, npmPath: 'npm' };
+  }
+
+  if (process.platform !== 'win32') {
+    throw new Error(
+      'npm is not available in PATH. Install Node.js 20+ first, then rerun the skill installer.'
+    );
+  }
+
+  if (!commandAvailable('winget')) {
+    throw new Error(
+      'npm is not available and winget is not installed. Install Node.js LTS manually, then rerun the skill installer.'
+    );
+  }
+
+  if (!options.quiet) {
+    process.stdout.write('npm is missing. Installing Node.js LTS through winget...\n');
+  }
+
+  installNodeJsWithWinget();
+
+  const npmPath = findInstalledNpm();
+  refreshPathFromNpm(npmPath);
+
+  if (!npmPath && !commandAvailable('npm')) {
+    throw new Error(
+      'Node.js was installed, but npm is still not visible in this shell. Restart the shell and rerun the skill installer.'
+    );
+  }
+
+  return {
+    installed: true,
+    skipped: false,
+    npmPath: npmPath || 'npm'
+  };
+}
+
+module.exports = {
+  ensureNpmRuntime,
+  commandAvailable,
+  findInstalledNpm
+};

package/index.js

@@ -0,0 +1,7 @@
+const packageJson = require('./package.json');
+
+module.exports = {
+  name: packageJson.name,
+  version: packageJson.version,
+  bin: packageJson.bin
+};

package/install.cmd

@@ -0,0 +1,5 @@
+@echo off
+setlocal
+set "SCRIPT_DIR=%~dp0"
+powershell -NoProfile -ExecutionPolicy Bypass -File "%SCRIPT_DIR%install.ps1" %*
+exit /b %ERRORLEVEL%