@pigcloud/skills 1.0.0

package/bin/cli.js

@@ -0,0 +1,663 @@
+#!/usr/bin/env node
+
+const fs = require('fs/promises');
+const fsSync = require('fs');
+const path = require('path');
+const os = require('os');
+const { detectRulesBundle } = require('./rules-loader');
+const { ensureNpmRuntime } = require('./runtime-bootstrap');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+const SKILLS_DIR = path.join(PACKAGE_ROOT, 'skills');
+const VERSION = require('../package.json').version;
+const CODEX_HOME = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+const AGENTS_HOME = path.join(os.homedir(), '.agents');
+const COMMAND_PACK_NAME = 'pig-cloud-skills-commands';
+const COMMAND_PACK_SOURCE = path.join(PACKAGE_ROOT, COMMAND_PACK_NAME);
+const CODEX_HOME_SKILLS_DIR = path.join(CODEX_HOME, 'skills');
+const AGENTS_PLUGINS_DIR = path.join(AGENTS_HOME, 'plugins');
+const AGENTS_MARKETPLACE_FILE = path.join(AGENTS_PLUGINS_DIR, 'marketplace.json');
+const INSTALL_ROOT = path.resolve(process.env.INIT_CWD || process.cwd());
+const SUPPORTED_TOOLS = ['codex', 'claude', 'trae', 'cursor', 'copilot', 'windsurf'];
+const TOOL_ALIASES = {
+  opencode: 'codex',
+  claude_code: 'claude'
+};
+
+const COLORS = {
+  reset: '\x1b[0m',
+  blue: '\x1b[34m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  gray: '\x1b[90m'
+};
+
+const chalk = {
+  blue: text => colorize(COLORS.blue, text),
+  green: text => colorize(COLORS.green, text),
+  red: text => colorize(COLORS.red, text),
+  yellow: text => colorize(COLORS.yellow, text),
+  gray: text => colorize(COLORS.gray, text)
+};
+
+const SKILLS = [
+  { name: 'workflow-router', category: 'core', description: 'route workflow stages' },
+  { name: 'technical-design', category: 'core', description: 'shape implementation design' },
+  { name: 'feature-build', category: 'core', description: 'implement features safely' },
+  { name: 'code-review', category: 'core', description: 'review code changes' },
+  { name: 'product-intake', category: 'analysis', description: 'capture product intent' },
+  { name: 'spec-refinement', category: 'analysis', description: 'turn demand into specs' },
+  { name: 'domain-modeling', category: 'analysis', description: 'extract domain knowledge' },
+  { name: 'api-docs', category: 'integration', description: 'document API contracts' },
+  { name: 'test-design', category: 'integration', description: 'design test coverage' },
+  { name: 'security-review', category: 'review', description: 'review security risks' },
+  { name: 'performance-check', category: 'review', description: 'review performance risks' },
+  { name: 'knowledge-capture', category: 'collaboration', description: 'capture reusable knowledge' },
+  { name: 'project-bootstrap', category: 'infrastructure', description: 'bootstrap project scaffolds' },
+  { name: 'environment-deploy', category: 'infrastructure', description: 'deploy supporting environments' }
+];
+
+const TOOL_CONFIGS = {
+  codex: { dir: '.agents/skills', rootFile: '.agents/AGENTS.md', markers: ['.agents/AGENTS.md', '.agents'] },
+  opencode: { dir: '.agents/skills', rootFile: '.agents/AGENTS.md', markers: ['.agents/AGENTS.md', '.agents'] },
+  claude: { dir: '.claude/skills', rootFile: '.claude/CLAUDE.md', markers: ['.claude/CLAUDE.md', '.claude'] },
+  claude_code: { dir: '.claude/skills', rootFile: '.claude/CLAUDE.md', markers: ['.claude/CLAUDE.md', '.claude'] },
+  trae: { dir: '.trae/skills', rootFile: '.trae/AGENTS.md', markers: ['.trae/AGENTS.md', '.trae'] },
+  cursor: { dir: '.cursor/rules', rootFile: '.cursor/rules/project-rules.mdc', markers: ['.cursor/rules/project-rules.mdc', '.cursor/rules'] },
+  copilot: { dir: '.github', rootFile: '.github/copilot-instructions.md', markers: ['.github/copilot-instructions.md'] },
+  windsurf: { dir: '.', rootFile: '.windsurfrules', markers: ['.windsurfrules'] }
+};
+
+function colorize(code, text) {
+  const value = String(text);
+  if (!process.stdout.isTTY) return value;
+  return `${code}${value}${COLORS.reset}`;
+}
+
+function normalizeSkillName(skill) {
+  return String(skill || '').trim();
+}
+
+function normalizeToolName(tool) {
+  if (!tool) return null;
+  const value = String(tool).trim().toLowerCase().replace(/[\s-]+/g, '_');
+  if (!value) return null;
+  if (['auto', 'detect', 'default'].includes(value)) return 'auto';
+  if (['all', '*'].includes(value)) return 'all';
+  if (Object.prototype.hasOwnProperty.call(TOOL_ALIASES, value)) return TOOL_ALIASES[value];
+  if (SUPPORTED_TOOLS.includes(value)) return value;
+  return null;
+}
+
+function parseToolList(value) {
+  if (!value) return [];
+  return String(value)
+    .split(',')
+    .map(item => normalizeToolName(item))
+    .filter(tool => tool && tool !== 'auto' && tool !== 'all');
+}
+
+function resolveRequestedTools(toolOption, cwd = getInstallRoot()) {
+  if (!toolOption) {
+    return detectTools(cwd);
+  }
+
+  const normalized = normalizeToolName(toolOption);
+  if (normalized === 'all') {
+    return [...SUPPORTED_TOOLS];
+  }
+
+  const explicitList = parseToolList(toolOption);
+  if (explicitList.length > 0) {
+    return [...new Set(explicitList)];
+  }
+
+  if (normalized === 'auto' || normalized === null) {
+    return detectTools(cwd);
+  }
+
+  return [normalized];
+}
+
+function getSkillInfo(name) {
+  return SKILLS.find(skill => skill.name === name);
+}
+
+function getSelectedSkills(rawSkills, includeAll = false) {
+  if (includeAll || !rawSkills) return [...SKILLS.map(skill => skill.name)];
+  return [...new Set(rawSkills.split(',').map(item => normalizeSkillName(item.trim())).filter(Boolean))];
+}
+
+function getInstallRoot(cwd = INSTALL_ROOT) {
+  return path.resolve(cwd);
+}
+
+function findWorkspaceRoot(startDir = getInstallRoot()) {
+  let current = getInstallRoot(startDir);
+
+  while (true) {
+    if (SUPPORTED_TOOLS.some(tool => hasToolMarker(tool, current))) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return startDir;
+    }
+
+    current = parent;
+  }
+}
+
+function hasToolMarker(tool, cwd = getInstallRoot()) {
+  const config = TOOL_CONFIGS[tool];
+  if (!config) return false;
+  return (config.markers || []).some(marker => fsSync.existsSync(path.join(cwd, marker)));
+}
+
+function detectTools(cwd = getInstallRoot()) {
+  const root = findWorkspaceRoot(cwd);
+  const rawOverride = process.env.PIG_SKILLS_TARGET_TOOL || process.env.PIG_SKILLS_TARGET_TOOLS;
+  const override = normalizeToolName(rawOverride);
+  const overrideList = parseToolList(rawOverride);
+
+  if (override === 'all') {
+    return [...SUPPORTED_TOOLS];
+  }
+  if (overrideList.length > 0) {
+    return [...new Set(overrideList)];
+  }
+
+  const detected = SUPPORTED_TOOLS.filter(tool => hasToolMarker(tool, root));
+  return detected.length > 0 ? detected : ['codex'];
+}
+
+function detectTool(cwd = getInstallRoot()) {
+  return detectTools(cwd)[0] || null;
+}
+
+function getTargetSkillDir(tool, cwd = process.cwd()) {
+  const config = TOOL_CONFIGS[tool];
+  if (!config) return null;
+  return path.join(cwd, config.dir);
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDir(targetPath) {
+  await fs.mkdir(targetPath, { recursive: true });
+}
+
+async function copyDirectory(sourcePath, destinationPath) {
+  await ensureDir(path.dirname(destinationPath));
+  await fs.cp(sourcePath, destinationPath, { recursive: true, force: true });
+}
+
+async function copyDirectoryIfMissing(sourcePath, destinationPath) {
+  if (await pathExists(destinationPath)) {
+    return false;
+  }
+
+  await copyDirectory(sourcePath, destinationPath);
+  return true;
+}
+
+async function readJson(filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(content);
+}
+
+async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+async function removePath(targetPath) {
+  await fs.rm(targetPath, { recursive: true, force: true });
+}
+
+async function copySkill(skillName, tool, cwd = process.cwd()) {
+  const skill = normalizeSkillName(skillName);
+  if (!getSkillInfo(skill)) {
+    throw new Error(`Unknown skill: ${skillName}`);
+  }
+
+  const targetSkillDir = getTargetSkillDir(tool, cwd);
+  if (!targetSkillDir) {
+    throw new Error(`Unsupported tool: ${tool}`);
+  }
+
+  const sourceDir = path.join(SKILLS_DIR, skill);
+  const destDir = path.join(targetSkillDir, skill);
+  await ensureDir(targetSkillDir);
+  await copyDirectory(sourceDir, destDir);
+}
+
+async function writeRootFile(tool, cwd = process.cwd()) {
+  const config = TOOL_CONFIGS[tool];
+  if (!config || !config.rootFile) return;
+
+  const rootTarget = path.join(cwd, config.rootFile);
+  const rootSource = path.join(PACKAGE_ROOT, path.basename(config.rootFile));
+  if (await pathExists(rootSource)) {
+    await ensureDir(path.dirname(rootTarget));
+    await fs.copyFile(rootSource, rootTarget);
+  }
+}
+
+async function copySkillToCodexHome(skillName) {
+  const skill = normalizeSkillName(skillName);
+  if (!getSkillInfo(skill)) {
+    throw new Error(`Unknown skill: ${skillName}`);
+  }
+
+  const sourceDir = path.join(SKILLS_DIR, skill);
+  const destDir = path.join(CODEX_HOME_SKILLS_DIR, skill);
+  await ensureDir(CODEX_HOME_SKILLS_DIR);
+  await copyDirectory(sourceDir, destDir);
+}
+
+function buildMarketplaceEntry(pluginName) {
+  return {
+    name: pluginName,
+    source: {
+      source: 'local',
+      path: `./plugins/${pluginName}`
+    },
+    policy: {
+      installation: 'AVAILABLE',
+      authentication: 'ON_INSTALL'
+    },
+    category: 'Productivity'
+  };
+}
+
+async function writeCodexMarketplaceEntry(pluginName) {
+  await ensureDir(AGENTS_PLUGINS_DIR);
+  const existing = (await pathExists(AGENTS_MARKETPLACE_FILE))
+    ? await readJson(AGENTS_MARKETPLACE_FILE)
+    : { name: 'personal', interface: { displayName: 'Personal' }, plugins: [] };
+
+  if (!existing.name) existing.name = 'personal';
+  if (!existing.interface) existing.interface = { displayName: 'Personal' };
+  if (!Array.isArray(existing.plugins)) existing.plugins = [];
+
+  const entry = buildMarketplaceEntry(pluginName);
+  const index = existing.plugins.findIndex(plugin => plugin && plugin.name === pluginName);
+  if (index >= 0) {
+    existing.plugins[index] = entry;
+  } else {
+    existing.plugins.push(entry);
+  }
+
+  await writeJson(AGENTS_MARKETPLACE_FILE, existing);
+}
+
+async function installCodexCommandPack() {
+  if (!(await pathExists(COMMAND_PACK_SOURCE))) {
+    throw new Error(`Codex command pack not found: ${COMMAND_PACK_SOURCE}`);
+  }
+
+  const destDir = path.join(AGENTS_PLUGINS_DIR, COMMAND_PACK_NAME);
+  await ensureDir(AGENTS_PLUGINS_DIR);
+  await copyDirectory(COMMAND_PACK_SOURCE, destDir);
+  await writeCodexMarketplaceEntry(COMMAND_PACK_NAME);
+}
+
+async function installSharedWorkspaceAssets(cwd = getInstallRoot()) {
+  const sharedAssets = [
+    { source: path.join(PACKAGE_ROOT, 'skills', 'references'), destination: path.join(cwd, 'skills', 'references') },
+    { source: path.join(PACKAGE_ROOT, 'rules'), destination: path.join(cwd, 'rules') }
+  ];
+
+  for (const asset of sharedAssets) {
+    if (await pathExists(asset.source)) {
+      await copyDirectoryIfMissing(asset.source, asset.destination);
+    }
+  }
+}
+
+async function installSkills(skills, tool, cwd = getInstallRoot()) {
+  await installSharedWorkspaceAssets(cwd);
+  for (const skill of skills) {
+    await copySkill(skill, tool, cwd);
+  }
+  await writeRootFile(tool, cwd);
+  if (tool === 'codex') {
+    for (const skill of skills) {
+      await copySkillToCodexHome(skill);
+    }
+    await installCodexCommandPack();
+  }
+}
+
+async function installSkillsForTools(skills, tools, cwd = getInstallRoot()) {
+  const uniqueTools = [...new Set(tools.filter(Boolean))];
+  if (uniqueTools.length === 0) {
+    throw new Error('Unable to resolve any install targets.');
+  }
+
+  for (const tool of uniqueTools) {
+    await installSkills(skills, tool, cwd);
+  }
+}
+
+function parseArgs(argv) {
+  const positionals = [];
+  const options = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--all') {
+      options.all = true;
+      continue;
+    }
+
+    if (token === '-t' || token === '--tool') {
+      options.tool = argv[++index];
+      continue;
+    }
+
+    if (token.startsWith('--tool=')) {
+      options.tool = token.slice('--tool='.length);
+      continue;
+    }
+
+    if (token === '-s' || token === '--skills') {
+      options.skills = argv[++index];
+      continue;
+    }
+
+    if (token.startsWith('--skills=')) {
+      options.skills = token.slice('--skills='.length);
+      continue;
+    }
+
+    if (token === '-b' || token === '--bundle') {
+      options.bundle = argv[++index];
+      continue;
+    }
+
+    if (token.startsWith('--bundle=')) {
+      options.bundle = token.slice('--bundle='.length);
+      continue;
+    }
+
+    if (token === '-k' || token === '--skill') {
+      options.skill = argv[++index];
+      continue;
+    }
+
+    if (token.startsWith('--skill=')) {
+      options.skill = token.slice('--skill='.length);
+      continue;
+    }
+
+    if (token === '-p' || token === '--profile') {
+      options.profile = argv[++index];
+      continue;
+    }
+
+    if (token.startsWith('--profile=')) {
+      options.profile = token.slice('--profile='.length);
+      continue;
+    }
+
+    if (token === '-f' || token === '--files') {
+      options.files = argv[++index];
+      continue;
+    }
+
+    if (token.startsWith('--files=')) {
+      options.files = token.slice('--files='.length);
+      continue;
+    }
+
+    positionals.push(token);
+  }
+
+  return { options, positionals };
+}
+
+function printHelp() {
+  console.log(chalk.blue('Pig Skills CLI'));
+  console.log(chalk.gray(`Version: ${VERSION}`));
+  console.log('');
+  console.log('Usage:');
+  console.log('  pig-skills init [--tool codex] [--skills a,b] [--all]');
+  console.log('  pig-skills auto [--skills a,b] [--all]');
+  console.log('  pig-skills codex [--skills a,b] [--all]');
+  console.log('  pig-skills bootstrap');
+  console.log('  pig-skills rules [--bundle <bundle>] [--profile <profile>] [--skill name] [--files a,b]');
+  console.log('  pig-skills rules [--bundle <bundle>] [--profile <profile>] [--files a,b]');
+  console.log('  pig-skills list');
+  console.log('  pig-skills add <skill> [--tool codex]');
+  console.log('  pig-skills remove <skill> [--tool codex]');
+  console.log('  pig-skills info <skill>');
+  console.log('  pig-skills update [--tool codex]');
+}
+
+async function ensureRuntimeForInstall() {
+  const result = await ensureNpmRuntime({ quiet: false });
+  if (result.installed) {
+    console.log(chalk.green('Installed Node.js/npm runtime for this session.'));
+  }
+  return result;
+}
+
+async function run() {
+  const { options, positionals } = parseArgs(process.argv.slice(2));
+  const command = positionals[0];
+
+  if (!command) {
+    printHelp();
+    return;
+  }
+
+  if (command === 'init') {
+    const skills = getSelectedSkills(options.skills, options.all || !options.skills);
+    try {
+      await ensureRuntimeForInstall();
+      const tools = resolveRequestedTools(options.tool);
+      await installSkillsForTools(skills, tools);
+      console.log(chalk.green(`Installed ${skills.length} skills for ${tools.join(', ')}`));
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'auto') {
+    const skills = getSelectedSkills(options.skills, options.all || !options.skills);
+    try {
+      await ensureRuntimeForInstall();
+      const tools = resolveRequestedTools('auto');
+      await installSkillsForTools(skills, tools);
+      console.log(chalk.green(`Auto-installed ${skills.length} skills for ${tools.join(', ')}`));
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'codex') {
+    const skills = getSelectedSkills(options.skills, options.all || !options.skills);
+    try {
+      await ensureRuntimeForInstall();
+      await installSkills(skills, 'codex');
+      console.log(chalk.green(`Synced ${skills.length} skills into Codex`));
+      console.log(chalk.green(`Installed Codex command pack: ${COMMAND_PACK_NAME}`));
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'rules') {
+    try {
+      if (options.bundle) {
+        process.env.PIG_SKILLS_RULE_BUNDLE = options.bundle;
+      }
+      if (options.profile) {
+        process.env.PIG_SKILLS_RULE_PROFILE = options.profile;
+      }
+      if (options.skill) {
+        process.env.PIG_SKILLS_RULE_SKILL = options.skill;
+      }
+      if (options.files) {
+        process.env.PIG_SKILLS_CHANGED_FILES = options.files;
+      }
+      const selection = detectRulesBundle(
+        process.env.INIT_CWD || process.cwd(),
+        options.files ? options.files.split(',').map(item => item.trim()).filter(Boolean) : []
+      );
+      console.log(JSON.stringify(selection, null, 2));
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'bootstrap') {
+    try {
+      const result = await ensureRuntimeForInstall();
+      if (result.skipped) {
+        console.log(chalk.yellow('Runtime bootstrap skipped by PIG_SKILLS_SKIP_RUNTIME_BOOTSTRAP.'));
+      } else if (result.installed) {
+        console.log(chalk.green('Node.js/npm runtime is ready.'));
+      } else {
+        console.log(chalk.green('Node.js/npm runtime is already available.'));
+      }
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'list') {
+    console.log(chalk.blue('Installed skills:'));
+    SKILLS.forEach(skill => {
+      console.log(chalk.green(`  鉁?${skill.name}`) + chalk.gray(` - ${skill.description}`));
+    });
+    console.log(chalk.gray(`\nTotal: ${SKILLS.length} skills`));
+    return;
+  }
+
+  if (command === 'add') {
+    const skillName = positionals[1];
+    if (!skillName) {
+      console.error(chalk.red('Missing skill name.'));
+      process.exitCode = 1;
+      return;
+    }
+
+    try {
+      await ensureRuntimeForInstall();
+      const tools = resolveRequestedTools(options.tool);
+      await installSharedWorkspaceAssets();
+      for (const tool of tools) {
+        await copySkill(skillName, tool);
+        await writeRootFile(tool);
+        if (tool === 'codex') {
+          await copySkillToCodexHome(skillName);
+          await installCodexCommandPack();
+        }
+      }
+      console.log(chalk.green(`Installed: ${normalizeSkillName(skillName)} -> ${tools.join(', ')}`));
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'remove') {
+    const skillName = positionals[1];
+    if (!skillName) {
+      console.error(chalk.red('Missing skill name.'));
+      process.exitCode = 1;
+      return;
+    }
+
+    const normalizedSkill = normalizeSkillName(skillName);
+    try {
+      const tools = resolveRequestedTools(options.tool);
+      let removedAny = false;
+      for (const tool of tools) {
+        const targetSkillDir = getTargetSkillDir(tool);
+        if (!targetSkillDir) continue;
+        const skillDir = path.join(targetSkillDir, normalizedSkill);
+        if (await pathExists(skillDir)) {
+          await removePath(skillDir);
+          removedAny = true;
+        }
+      }
+      console.log(removedAny
+        ? chalk.green(`Removed: ${normalizedSkill}`)
+        : chalk.yellow(`Skill not found: ${normalizedSkill}`));
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (command === 'info') {
+    const skillName = positionals[1];
+    if (!skillName) {
+      console.error(chalk.red('Missing skill name.'));
+      process.exitCode = 1;
+      return;
+    }
+
+    const normalizedSkill = normalizeSkillName(skillName);
+    const info = getSkillInfo(normalizedSkill);
+    if (!info) {
+      console.error(chalk.red(`Unknown skill: ${skillName}`));
+      process.exitCode = 1;
+      return;
+    }
+
+    console.log(chalk.blue(info.name));
+    console.log(chalk.gray(`Category: ${info.category}`));
+    console.log(chalk.gray(`Description: ${info.description}`));
+    console.log(chalk.gray(`Path: skills/${info.name}/SKILL.md`));
+    return;
+  }
+
+  if (command === 'update') {
+    try {
+      await ensureRuntimeForInstall();
+      const tools = resolveRequestedTools(options.tool);
+      await installSkillsForTools(SKILLS.map(skill => skill.name), tools);
+      console.log(chalk.green(`Updated ${SKILLS.length} skills for ${tools.join(', ')}`));
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  console.error(chalk.red(`Unknown command: ${command}`));
+  printHelp();
+  process.exitCode = 1;
+}
+
+run().catch(error => {
+  console.error(chalk.red(error.message));
+  process.exitCode = 1;
+});
+