yuanflow-cli 0.1.0 → 0.1.2

package/lib/skill-installer/agents.cjs

@@ -0,0 +1,203 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs');
+
+const SUPPORTED_AGENTS = [
+  'codex',
+  'claude-code',
+  'cursor',
+  'trae',
+  'opencode',
+  'github-copilot',
+  'gemini-cli',
+  'kimi-cli',
+  'windsurf',
+  'openclaw',
+  'trae-cn',
+  'qoder',
+  'qwen-code',
+];
+
+function defaultExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function getConfigHome(homeDir, env) {
+  return (env && env.XDG_CONFIG_HOME) || path.join(homeDir, '.config');
+}
+
+function getCanonicalSkillsDir({
+  homeDir = os.homedir(),
+  cwd = process.cwd(),
+  scope = 'global',
+} = {}) {
+  const baseDir = scope === 'project' ? cwd : homeDir;
+  return path.join(baseDir, '.yuanflow-skill', 'skills');
+}
+
+function buildAgentDefinitions({ homeDir = os.homedir(), env = process.env } = {}) {
+  const configHome = getConfigHome(homeDir, env);
+  const codexHome = (env.CODEX_HOME || '').trim() || path.join(homeDir, '.codex');
+  const claudeHome = (env.CLAUDE_CONFIG_DIR || '').trim() || path.join(homeDir, '.claude');
+
+  return {
+    codex: {
+      name: 'codex',
+      displayName: 'Codex',
+      projectSkillsDir: '.agents/skills',
+      globalSkillsDir: path.join(codexHome, 'skills'),
+      markers: [codexHome],
+    },
+    'claude-code': {
+      name: 'claude-code',
+      displayName: 'Claude Code',
+      projectSkillsDir: '.claude/skills',
+      globalSkillsDir: path.join(claudeHome, 'skills'),
+      markers: [claudeHome],
+    },
+    cursor: {
+      name: 'cursor',
+      displayName: 'Cursor',
+      projectSkillsDir: '.agents/skills',
+      globalSkillsDir: path.join(homeDir, '.cursor', 'skills'),
+      markers: [path.join(homeDir, '.cursor')],
+    },
+    trae: {
+      name: 'trae',
+      displayName: 'Trae',
+      projectSkillsDir: '.trae/skills',
+      globalSkillsDir: path.join(homeDir, '.trae', 'skills'),
+      markers: [path.join(homeDir, '.trae')],
+    },
+    opencode: {
+      name: 'opencode',
+      displayName: 'OpenCode',
+      projectSkillsDir: '.agents/skills',
+      globalSkillsDir: path.join(configHome, 'opencode', 'skills'),
+      markers: [path.join(configHome, 'opencode')],
+    },
+    'github-copilot': {
+      name: 'github-copilot',
+      displayName: 'GitHub Copilot',
+      projectSkillsDir: '.agents/skills',
+      globalSkillsDir: path.join(homeDir, '.copilot', 'skills'),
+      markers: [path.join(homeDir, '.copilot')],
+    },
+    'gemini-cli': {
+      name: 'gemini-cli',
+      displayName: 'Gemini CLI',
+      projectSkillsDir: '.agents/skills',
+      globalSkillsDir: path.join(homeDir, '.gemini', 'skills'),
+      markers: [path.join(homeDir, '.gemini')],
+    },
+    'kimi-cli': {
+      name: 'kimi-cli',
+      displayName: 'Kimi Code CLI',
+      projectSkillsDir: '.agents/skills',
+      globalSkillsDir: path.join(configHome, 'agents', 'skills'),
+      markers: [path.join(homeDir, '.kimi')],
+    },
+    windsurf: {
+      name: 'windsurf',
+      displayName: 'Windsurf',
+      projectSkillsDir: '.windsurf/skills',
+      globalSkillsDir: path.join(homeDir, '.codeium', 'windsurf', 'skills'),
+      markers: [path.join(homeDir, '.codeium', 'windsurf')],
+    },
+    openclaw: {
+      name: 'openclaw',
+      displayName: 'OpenClaw',
+      projectSkillsDir: 'skills',
+      globalSkillsDir: path.join(homeDir, '.openclaw', 'skills'),
+      markers: [
+        path.join(homeDir, '.openclaw'),
+        path.join(homeDir, '.clawdbot'),
+        path.join(homeDir, '.moltbot'),
+      ],
+      resolveGlobalSkillsDir(currentHomeDir, exists = defaultExists) {
+        if (exists(path.join(currentHomeDir, '.openclaw'))) {
+          return path.join(currentHomeDir, '.openclaw', 'skills');
+        }
+        if (exists(path.join(currentHomeDir, '.clawdbot'))) {
+          return path.join(currentHomeDir, '.clawdbot', 'skills');
+        }
+        if (exists(path.join(currentHomeDir, '.moltbot'))) {
+          return path.join(currentHomeDir, '.moltbot', 'skills');
+        }
+
+        return path.join(currentHomeDir, '.openclaw', 'skills');
+      },
+    },
+    'trae-cn': {
+      name: 'trae-cn',
+      displayName: 'Trae CN',
+      projectSkillsDir: '.trae/skills',
+      globalSkillsDir: path.join(homeDir, '.trae-cn', 'skills'),
+      markers: [path.join(homeDir, '.trae-cn')],
+    },
+    qoder: {
+      name: 'qoder',
+      displayName: 'Qoder',
+      projectSkillsDir: '.qoder/skills',
+      globalSkillsDir: path.join(homeDir, '.qoder', 'skills'),
+      markers: [path.join(homeDir, '.qoder')],
+    },
+    'qwen-code': {
+      name: 'qwen-code',
+      displayName: 'Qwen Code',
+      projectSkillsDir: '.qwen/skills',
+      globalSkillsDir: path.join(homeDir, '.qwen', 'skills'),
+      markers: [path.join(homeDir, '.qwen')],
+    },
+  };
+}
+
+function getSupportedAgents() {
+  return [...SUPPORTED_AGENTS];
+}
+
+function getAgentConfig(agentName, options = {}) {
+  const definitions = buildAgentDefinitions(options);
+  const exists = options.exists || defaultExists;
+  const agent = definitions[agentName];
+
+  if (!agent) {
+    throw new Error(`Unsupported agent: ${agentName}`);
+  }
+
+  if (typeof agent.resolveGlobalSkillsDir === 'function') {
+    return {
+      ...agent,
+      globalSkillsDir: agent.resolveGlobalSkillsDir(options.homeDir || os.homedir(), exists),
+    };
+  }
+
+  return agent;
+}
+
+function getTargetBaseDir(agent, { scope = 'global', cwd = process.cwd() } = {}) {
+  if (scope === 'project') {
+    return path.join(cwd, agent.projectSkillsDir);
+  }
+
+  return agent.globalSkillsDir;
+}
+
+function detectInstalledAgents(options = {}) {
+  const exists = options.exists || defaultExists;
+  const homeDir = options.homeDir || os.homedir();
+
+  return SUPPORTED_AGENTS.filter((agentName) => {
+    const agent = getAgentConfig(agentName, options);
+    return agent.markers.some((markerPath) => exists(markerPath.replace(/^~(?=$|[\\/])/, homeDir)));
+  });
+}
+
+module.exports = {
+  SUPPORTED_AGENTS,
+  getSupportedAgents,
+  getCanonicalSkillsDir,
+  getAgentConfig,
+  getTargetBaseDir,
+  detectInstalledAgents,
+};

package/lib/skill-installer/discover-skills.cjs

@@ -0,0 +1,79 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+
+  if (!match) {
+    return {};
+  }
+
+  const result = {};
+  const lines = match[1].split(/\r?\n/);
+
+  for (const line of lines) {
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const key = line.slice(0, separatorIndex).trim();
+    const value = line
+      .slice(separatorIndex + 1)
+      .trim()
+      .replace(/^['"]|['"]$/g, '');
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+function readSkill(skillDir, isRootSkill = false) {
+  const skillPath = path.join(skillDir, 'SKILL.md');
+  if (!fs.existsSync(skillPath)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(skillPath, 'utf8');
+  const frontmatter = parseFrontmatter(content);
+
+  if (!frontmatter.name || !frontmatter.description) {
+    throw new Error(`Invalid SKILL.md metadata: ${skillPath}`);
+  }
+
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    sourceDir: skillDir,
+    skillFile: skillPath,
+    rootSkill: isRootSkill,
+  };
+}
+
+function discoverSkills(packageRoot) {
+  const skills = [];
+  const rootSkill = readSkill(packageRoot, true);
+
+  if (rootSkill) {
+    skills.push(rootSkill);
+  }
+
+  const entries = fs.readdirSync(packageRoot, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const nestedSkill = readSkill(path.join(packageRoot, entry.name), false);
+    if (nestedSkill) {
+      skills.push(nestedSkill);
+    }
+  }
+
+  return skills;
+}
+
+module.exports = {
+  discoverSkills,
+};

package/lib/skill-installer/installer.cjs

@@ -0,0 +1,300 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { getCanonicalSkillsDir, getTargetBaseDir } = require('./agents.cjs');
+
+const EXCLUDED_NAMES = new Set([
+  '.git',
+  '.gitignore',
+  '__pycache__',
+  '.venv',
+  'node_modules',
+  'memory.md',
+  '.DS_Store',
+]);
+
+function sanitizeName(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function ensureDir(targetDir) {
+  fs.mkdirSync(targetDir, { recursive: true });
+}
+
+function removePath(targetPath) {
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function copyDirectory(sourceDir, targetDir) {
+  ensureDir(targetDir);
+
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (EXCLUDED_NAMES.has(entry.name)) {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(sourcePath, targetPath);
+      continue;
+    }
+
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+}
+
+function copySkill(skill, targetDir) {
+  ensureDir(targetDir);
+
+  if (skill.rootSkill) {
+    fs.copyFileSync(skill.skillFile, path.join(targetDir, 'SKILL.md'));
+    return;
+  }
+
+  copyDirectory(skill.sourceDir, targetDir);
+}
+
+function getBundleSkill(skills) {
+  const rootSkill = skills.find((skill) => skill.rootSkill);
+  if (rootSkill) {
+    return rootSkill;
+  }
+
+  if (skills.length === 0) {
+    throw new Error('No skills were provided for installation.');
+  }
+
+  return skills[0];
+}
+
+function copySkillBundle(sourceDir, targetDir) {
+  copyDirectory(sourceDir, targetDir);
+}
+
+function getLegacySkillEntries({ canonicalDir, targetAgents, skills, scope = 'global', cwd = process.cwd() }) {
+  const bundleSkill = getBundleSkill(skills);
+  const bundleSlug = sanitizeName(bundleSkill.name);
+  const legacySkills = skills.filter((skill) => sanitizeName(skill.name) !== bundleSlug);
+  const entries = [];
+
+  for (const skill of legacySkills) {
+    const skillSlug = sanitizeName(skill.name);
+    const legacyCanonicalDir = path.join(canonicalDir, skillSlug);
+
+    for (const agent of targetAgents) {
+      const agentBaseDir = getTargetBaseDir(agent, { scope, cwd });
+      entries.push({
+        skillName: skill.name,
+        skillSlug,
+        canonicalDir: legacyCanonicalDir,
+        targetDir: path.join(agentBaseDir, skillSlug),
+      });
+    }
+  }
+
+  return entries;
+}
+
+function createSymlink(targetDir, linkPath) {
+  try {
+    ensureDir(path.dirname(linkPath));
+    removePath(linkPath);
+    fs.symlinkSync(targetDir, linkPath, process.platform === 'win32' ? 'junction' : 'dir');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getInstallPlan({ canonicalDir, targetAgents, skills, scope = 'global', cwd = process.cwd() }) {
+  const bundleSkill = getBundleSkill(skills);
+  const plan = [];
+  const skillSlug = sanitizeName(bundleSkill.name);
+  const skillCanonicalDir = path.join(canonicalDir, skillSlug);
+
+  for (const agent of targetAgents) {
+    const agentBaseDir = getTargetBaseDir(agent, { scope, cwd });
+    plan.push({
+      skillName: bundleSkill.name,
+      skillSlug,
+      sourceDir: bundleSkill.sourceDir,
+      canonicalDir: skillCanonicalDir,
+      agentName: agent.name,
+      targetDir: path.join(agentBaseDir, skillSlug),
+    });
+  }
+
+  return plan;
+}
+
+function getUninstallPlan({
+  canonicalDir,
+  targetAgents,
+  bundleName,
+  scope = 'global',
+  cwd = process.cwd(),
+}) {
+  const plan = [];
+  const skillSlug = sanitizeName(bundleName);
+
+  for (const agent of targetAgents) {
+    const agentBaseDir = getTargetBaseDir(agent, { scope, cwd });
+    plan.push({
+      skillName: bundleName,
+      skillSlug,
+      canonicalDir: path.join(canonicalDir, skillSlug),
+      agentName: agent.name,
+      targetDir: path.join(agentBaseDir, skillSlug),
+    });
+  }
+
+  return plan;
+}
+
+function installSkills({
+  packageRoot,
+  skills,
+  targetAgents,
+  mode = 'symlink',
+  scope = 'global',
+  cwd = process.cwd(),
+  dryRun = false,
+  homeDir = os.homedir(),
+}) {
+  const canonicalDir = getCanonicalSkillsDir({
+    homeDir,
+    cwd,
+    scope,
+  });
+  ensureDir(canonicalDir);
+
+  const plan = getInstallPlan({
+    canonicalDir,
+    targetAgents,
+    skills,
+    scope,
+    cwd,
+  });
+  const legacyEntries = getLegacySkillEntries({
+    canonicalDir,
+    targetAgents,
+    skills,
+    scope,
+    cwd,
+  });
+
+  const results = [];
+  const bundleSkill = getBundleSkill(skills);
+
+  if (!dryRun) {
+    for (const legacyEntry of legacyEntries) {
+      removePath(legacyEntry.canonicalDir);
+      removePath(legacyEntry.targetDir);
+    }
+  }
+
+  for (const entry of plan) {
+    const overwriteCanonical = pathExists(entry.canonicalDir);
+    const overwriteTarget = pathExists(entry.targetDir);
+
+    if (!dryRun) {
+      removePath(entry.canonicalDir);
+      ensureDir(entry.canonicalDir);
+      copySkillBundle(bundleSkill.sourceDir, entry.canonicalDir);
+    }
+
+    let installedBy = mode === 'symlink' ? 'symlink' : 'copy';
+    if (!dryRun) {
+      if (mode === 'symlink') {
+        const linked = createSymlink(entry.canonicalDir, entry.targetDir);
+        if (!linked) {
+          installedBy = 'copy';
+          removePath(entry.targetDir);
+          copyDirectory(entry.canonicalDir, entry.targetDir);
+        }
+      } else {
+        removePath(entry.targetDir);
+        copyDirectory(entry.canonicalDir, entry.targetDir);
+      }
+    }
+
+    results.push({
+      ...entry,
+      installedBy,
+      overwriteCanonical,
+      overwriteTarget,
+      scope,
+      packageRoot,
+      dryRun,
+    });
+  }
+
+  return results;
+}
+
+function uninstallSkills({
+  skillNames,
+  targetAgents,
+  scope = 'global',
+  cwd = process.cwd(),
+  dryRun = false,
+  homeDir = os.homedir(),
+  bundleName = 'yuanflow-skill',
+}) {
+  const canonicalDir = getCanonicalSkillsDir({
+    homeDir,
+    cwd,
+    scope,
+  });
+
+  const plan = getUninstallPlan({
+    canonicalDir,
+    targetAgents,
+    bundleName,
+    scope,
+    cwd,
+  });
+
+  const results = [];
+
+  for (const entry of plan) {
+    const targetExists = pathExists(entry.targetDir);
+    const canonicalExists = pathExists(entry.canonicalDir);
+
+    if (!dryRun) {
+      removePath(entry.targetDir);
+      removePath(entry.canonicalDir);
+    }
+
+    results.push({
+      ...entry,
+      removedTarget: targetExists,
+      removedCanonical: canonicalExists,
+      dryRun,
+      scope,
+    });
+  }
+
+  return results;
+}
+
+module.exports = {
+  sanitizeName,
+  getBundleSkill,
+  getLegacySkillEntries,
+  getInstallPlan,
+  getUninstallPlan,
+  installSkills,
+  uninstallSkills,
+};

package/lib/skill-installer/publish.cjs

@@ -0,0 +1,53 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function isSemver(version) {
+  return /^\d+\.\d+\.\d+(-[0-9A-Za-z-.]+)?$/.test(version || '');
+}
+
+function buildReleaseChecklist({
+  packageJson,
+  packageRoot,
+  repoConfig,
+  fileExists = (targetPath) => fs.existsSync(targetPath),
+}) {
+  const items = [
+    {
+      label: 'package.json name',
+      ok: Boolean(packageJson.name && String(packageJson.name).trim()),
+    },
+    {
+      label: 'package.json version',
+      ok: isSemver(packageJson.version),
+    },
+    {
+      label: 'README.md exists',
+      ok: fileExists(path.join(packageRoot, 'README.md')),
+    },
+    {
+      label: 'skill repo source configured',
+      ok: Boolean(repoConfig && repoConfig.owner && repoConfig.repo && repoConfig.ref),
+    },
+    {
+      label: 'test script exists',
+      ok: Boolean(packageJson.scripts && packageJson.scripts.test),
+    },
+    {
+      label: 'pack:check script exists',
+      ok: Boolean(packageJson.scripts && packageJson.scripts['pack:check']),
+    },
+    {
+      label: 'postinstall script exists',
+      ok: Boolean(packageJson.scripts && packageJson.scripts.postinstall),
+    },
+  ];
+
+  return {
+    ok: items.every((item) => item.ok),
+    items,
+  };
+}
+
+module.exports = {
+  buildReleaseChecklist,
+};