skillcaddy 0.27.0

package/skills/skillcaddy-manager/scripts/check-conflicts.cjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * Print comparable collection profiles for agent review.
+ * The script preserves the historical command name but does not decide conflicts.
+ *
+ * Usage:
+ *   node check-conflicts.cjs <collection-id>
+ *   node check-conflicts.cjs <collection-id> --against <id,id,...>
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const dataPath = path.join(__dirname, '..', 'references', 'featured-skills.json');
+
+function loadJSON(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function parseArgs(argv) {
+  const args = [...argv];
+  const collectionId = args.shift() || '';
+  let against = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--against') {
+      against = String(args[index + 1] || '').split(',').filter(Boolean);
+      index += 1;
+    } else if (arg.startsWith('--against=')) {
+      against = arg.slice('--against='.length).split(',').filter(Boolean);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return { collectionId, against };
+}
+
+function getCollections(data) {
+  return Object.values(data.featured || {})
+    .flatMap(category => category.collections || []);
+}
+
+function summarizeCollection(collection) {
+  return {
+    id: collection.id,
+    name: collection.name || collection.id,
+    description: collection.description || collection.reason || collection.note || '',
+    tags: collection.tags || [],
+    capabilities: collection.skills || collection.includes || []
+  };
+}
+
+function buildComparison(collections, candidateId, againstIds = []) {
+  const byId = new Map(collections.map(collection => [collection.id, collection]));
+  const candidate = byId.get(candidateId);
+  if (!candidate) throw new Error(`Unknown collection: ${candidateId}`);
+
+  const targetIds = againstIds.length > 0
+    ? againstIds
+    : collections.map(collection => collection.id).filter(id => id !== candidateId);
+
+  const comparisons = targetIds
+    .filter(id => id !== candidateId)
+    .map(id => {
+      const collection = byId.get(id);
+      if (!collection) throw new Error(`Unknown comparison collection: ${id}`);
+      return summarizeCollection(collection);
+    });
+
+  return {
+    candidate: summarizeCollection(candidate),
+    comparisons
+  };
+}
+
+function printProfile(label, collection) {
+  console.log(`## ${label}: ${collection.id}`);
+  console.log(`名称: ${collection.name}`);
+  console.log(`描述: ${collection.description || '无'}`);
+  console.log(`标签: ${collection.tags.join(', ') || '无'}`);
+  console.log(`能力: ${collection.capabilities.join(', ') || '无'}\n`);
+}
+
+function printReport(result) {
+  console.log('# Skillcaddy 能力重叠审查素材\n');
+  printProfile('候选库', result.candidate);
+  for (const comparison of result.comparisons) {
+    printProfile('对照库', comparison);
+  }
+  console.log('请根据名称、描述、标签和能力清单判断它们是互补、重复还是信息不足。');
+  console.log('本脚本不包含固定库名规则，也不自动给出冲突结论。');
+}
+
+if (require.main === module) {
+  try {
+    const { collectionId, against } = parseArgs(process.argv.slice(2));
+    if (!collectionId) {
+      console.error('Usage: node check-conflicts.cjs <collection-id> [--against <id,id,...>]');
+      process.exitCode = 1;
+    } else {
+      const data = loadJSON(dataPath);
+      printReport(buildComparison(getCollections(data), collectionId, against));
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  buildComparison,
+  getCollections,
+  parseArgs,
+  summarizeCollection
+};

package/skills/skillcaddy-manager/scripts/check-global-skills.cjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+/**
+ * 全局 Skills 检测脚本
+ * 用法: node check-global-skills.cjs
+ *
+ * 检测全局 skills 目录,建议用户安装 skillcaddy
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// 跨平台路径检测
+const globalPaths = {
+  darwin: {
+    codex: path.join(os.homedir(), '.agents/skills'),
+    claude: path.join(os.homedir(), '.claude/skills')
+  },
+  linux: {
+    codex: path.join(os.homedir(), '.agents/skills'),
+    claude: path.join(os.homedir(), '.claude/skills')
+  },
+  win32: {
+    codex: path.join(os.homedir(), '.agents/skills'),
+    claude: path.join(os.homedir(), '.claude/skills'),
+    // Windows 可能的其他路径
+    codexAlt: path.join(process.env.APPDATA || '', '.agents/skills'),
+    claudeAlt: path.join(process.env.APPDATA || '', '.claude/skills')
+  }
+};
+
+function checkGlobalSkills() {
+  const platform = os.platform();
+  const paths = globalPaths[platform] || globalPaths.darwin;
+
+  const results = {
+    platform: platform,
+    hasGlobalSkills: false,
+    hasSkillcaddy: false,
+    globalPaths: [],
+    skillcaddyPaths: [],
+    recommendations: []
+  };
+
+  // 检查每个可能的路径
+  for (const [type, skillPath] of Object.entries(paths)) {
+    if (!skillPath) continue;
+
+    if (fs.existsSync(skillPath)) {
+      const isDir = fs.statSync(skillPath).isDirectory();
+      if (isDir) {
+        results.hasGlobalSkills = true;
+        results.globalPaths.push({ type, path: skillPath });
+
+        // 检查是否包含 skillcaddy-manager
+        const skillcaddyPath = path.join(skillPath, 'skillcaddy-manager');
+        if (fs.existsSync(skillcaddyPath)) {
+          results.hasSkillcaddy = true;
+          results.skillcaddyPaths.push(skillcaddyPath);
+        }
+
+        // 检查目录内容
+        try {
+          const items = fs.readdirSync(skillPath).filter(item => {
+            const itemPath = path.join(skillPath, item);
+            return fs.statSync(itemPath).isDirectory() && !item.startsWith('.');
+          });
+
+          if (items.length > 0 && !results.skillCount) {
+            results.skillCount = items.length;
+            results.skillList = items.slice(0, 5); // 只显示前5个
+          }
+        } catch (err) {
+          // 忽略读取错误
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+function printReport(results) {
+  console.log('## 🔍 全局 Skills 检测报告\n');
+  console.log(`**操作系统**: ${results.platform}\n`);
+
+  if (!results.hasGlobalSkills) {
+    console.log('✅ 未检测到全局 skills 目录\n');
+    console.log('建议:');
+    console.log('  - 如需管理多个项目的 skills,可安装 Skillcaddy');
+    console.log('  - 访问: https://github.com/chenweil/skillcaddy\n');
+    return;
+  }
+
+  console.log('📁 检测到全局 Skills 目录:\n');
+  results.globalPaths.forEach(({ type, path }) => {
+    console.log(`  ${type}: ${path}`);
+  });
+
+  if (results.skillCount) {
+    console.log(`\n📊 发现 ${results.skillCount} 个全局 skills:`);
+    results.skillList.forEach(skill => {
+      console.log(`  - ${skill}`);
+    });
+    if (results.skillCount > 5) {
+      console.log(`  ... 还有 ${results.skillCount - 5} 个`);
+    }
+  }
+
+  console.log('\n---\n');
+
+  if (results.hasSkillcaddy) {
+    console.log('✅ 已安装 Skillcaddy\n');
+    console.log('全局 skillcaddy-manager 位置:');
+    results.skillcaddyPaths.forEach(p => {
+      console.log(`  ${p}`);
+    });
+    console.log('\n💡 建议:');
+    console.log('  - 在项目中使用 skillcaddy-manager 启用/禁用 skills');
+    console.log('  - 使用 Web UI 管理: http://127.0.0.1:4173\n');
+  } else {
+    console.log('⚠️ 未检测到 Skillcaddy\n');
+    console.log('💡 建议安装 Skillcaddy:\n');
+    console.log('**为什么需要 Skillcaddy?**');
+    console.log('  - ✅ 集中管理所有 skills (单一事实来源)');
+    console.log('  - ✅ 按项目启用/禁用 (避免污染)');
+    console.log('  - ✅ 多 Agent 兼容 (Claude Code / Codex / OpenCode)');
+    console.log('  - ✅ 版本控制和更新管理');
+    console.log('  - ✅ 避免重复复制和版本漂移\n');
+
+    console.log('**安装步骤:**');
+    console.log('```bash');
+    console.log('# 克隆 Skillcaddy');
+    console.log('git clone https://github.com/chenweil/skillcaddy.git');
+    console.log('cd skillcaddy');
+    console.log('');
+    console.log('# 启动 Web 管理器');
+    console.log('npm start');
+    console.log('');
+    console.log('# 访问 http://127.0.0.1:4173');
+    console.log('```\n');
+
+    console.log('**迁移全局 Skills 到 Skillcaddy:**');
+    console.log('```bash');
+    console.log('# 1. 将全局 skills 移动到 Skillcaddy 库');
+    console.log('mv ~/.agents/skills/my-skill /path/to/skillcaddy/personal/my-skill');
+    console.log('');
+    console.log('# 2. 删除全局目录 (可选)');
+    console.log('rm -rf ~/.agents/skills');
+    console.log('');
+    console.log('# 3. 在项目中按需启用');
+    console.log('# 使用 Web UI 或 skillcaddy-manager skill');
+    console.log('```\n');
+
+    console.log('**了解更多:**');
+    console.log('  - GitHub: https://github.com/chenweil/skillcaddy');
+    console.log('  - 文档: /path/to/skillcaddy/README.md\n');
+  }
+}
+
+// 主程序
+const results = checkGlobalSkills();
+printReport(results);
+
+// 导出函数供其他脚本使用
+module.exports = {
+  checkGlobalSkills,
+  globalPaths
+};

package/skills/skillcaddy-manager/scripts/translate-skill-notes.cjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_PORT = 4173;
+const REQUEST_TIMEOUT_MS = 10_000;
+const MAX_NOTE_LENGTH = 500;
+const MAX_TAGS = 12;
+const MAX_TAG_LENGTH = 40;
+
+function parseArgs(argv) {
+  const opts = {
+    command: '',
+    file: '',
+    port: DEFAULT_PORT,
+    project: '.',
+    yes: false,
+    forceRewrite: false
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === 'list' || arg === 'apply') opts.command = arg;
+    else if (arg === '--yes') opts.yes = true;
+    else if (arg === '--force-rewrite') opts.forceRewrite = true;
+    else if (arg.startsWith('--port=')) opts.port = parsePort(arg.slice('--port='.length));
+    else if (arg === '--port') opts.port = parsePort(argv[++index]);
+    else if (arg.startsWith('--project=')) opts.project = arg.slice('--project='.length);
+    else if (arg === '--project') opts.project = argv[++index] || '.';
+    else if (!arg.startsWith('--') && !opts.file) opts.file = arg;
+    else throw new Error(`未知参数: ${arg}`);
+  }
+
+  return opts;
+}
+
+function parsePort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) throw new Error(`无效端口: ${value}`);
+  return port;
+}
+
+async function fetchState(port, project) {
+  const url = `http://127.0.0.1:${port}/api/state?projectPath=${encodeURIComponent(path.resolve(project))}`;
+  return requestJson(url);
+}
+
+async function postMetadata(port, payload) {
+  return requestJson(`http://127.0.0.1:${port}/api/skill-metadata`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload)
+  });
+}
+
+async function requestJson(url, options = {}) {
+  const res = await fetch(url, {
+    ...options,
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  const text = await res.text();
+  let body;
+  try {
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(`${options.method || 'GET'} ${url} 返回了无效 JSON`);
+  }
+  if (!res.ok || body.ok === false) {
+    throw new Error(body.error || `${options.method || 'GET'} ${url} failed: ${res.status}`);
+  }
+  return body;
+}
+
+function needsTranslation(skill) {
+  if (skill.source === 'archived') return false;
+  if (String(skill.note || '').trim()) return false;
+
+  const description = String(skill.description || '').trim();
+  if (!hasMeaningfulText(description)) return false;
+  return !isMostlyChinese(description);
+}
+
+function hasMeaningfulText(value) {
+  return (String(value).match(/[A-Za-z\u3400-\u9fff]/gu) || []).length >= 3;
+}
+
+function isMostlyChinese(value) {
+  const text = String(value);
+  const chinese = (text.match(/[\u3400-\u9fff]/gu) || []).length;
+  const latin = (text.match(/[A-Za-z]/g) || []).length;
+  return chinese >= 4 && chinese >= latin;
+}
+
+function createTranslationManifest(state) {
+  return {
+    schemaVersion: 1,
+    libraryRoot: path.resolve(state.rootDir),
+    entries: (state.skills || [])
+      .filter(needsTranslation)
+      .map((skill) => ({
+        id: skill.id,
+        source: skill.source,
+        collection: skill.collection,
+        name: skill.name,
+        description: skill.description,
+        note: ''
+      }))
+  };
+}
+
+function parseManifest(raw) {
+  const manifest = JSON.parse(raw);
+  if (!manifest || Array.isArray(manifest) || typeof manifest !== 'object') throw new Error('manifest 必须是带 libraryRoot 和 entries 的对象');
+  if (manifest.schemaVersion !== 1) throw new Error('manifest schemaVersion 必须是 1');
+  if (!manifest.libraryRoot || typeof manifest.libraryRoot !== 'string') throw new Error('manifest 缺少 libraryRoot');
+  if (!Array.isArray(manifest.entries)) throw new Error('manifest entries 必须是数组');
+  return manifest;
+}
+
+function preflightManifest(manifest, state, options = {}) {
+  const errors = [];
+  const changes = [];
+  const unchanged = [];
+  const seenIds = new Set();
+  const expectedRoot = path.resolve(state.rootDir);
+
+  if (path.resolve(manifest.libraryRoot) !== expectedRoot) {
+    errors.push(`libraryRoot 不匹配: manifest=${path.resolve(manifest.libraryRoot)} server=${expectedRoot}`);
+  }
+
+  const byId = new Map((state.skills || []).map((skill) => [skill.id, skill]));
+  manifest.entries.forEach((entry, index) => {
+    const label = entry?.id || `entries[${index}]`;
+    try {
+      const normalized = normalizeEntry(entry, label);
+      if (seenIds.has(normalized.id)) throw new Error('id 重复');
+      seenIds.add(normalized.id);
+
+      const skill = byId.get(normalized.id);
+      if (!skill) throw new Error('找不到对应 skill');
+      const currentNote = String(skill.note || '').trim();
+      if (currentNote && currentNote !== normalized.note && !options.forceRewrite) {
+        throw new Error('已有 note，默认拒绝覆盖；确需重写时使用 --force-rewrite');
+      }
+
+      const payload = {
+        skillPath: skill.path,
+        note: normalized.note,
+        tags: normalized.tags ?? skill.tags ?? [],
+        autoEnable: normalized.autoEnable ?? skill.autoEnable ?? true
+      };
+      if (metadataMatches(skill, payload)) unchanged.push(normalized.id);
+      else changes.push({ id: normalized.id, skill, payload });
+    } catch (error) {
+      errors.push(`${label}: ${error.message}`);
+    }
+  });
+
+  if (errors.length > 0) {
+    const error = new Error(`预检失败:\n- ${errors.join('\n- ')}`);
+    error.errors = errors;
+    throw error;
+  }
+
+  return { libraryRoot: expectedRoot, changes, unchanged };
+}
+
+function normalizeEntry(entry, label) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) throw new Error('条目必须是对象');
+  const id = typeof entry.id === 'string' ? entry.id.trim() : '';
+  if (!id) throw new Error('id 不能为空');
+  if (typeof entry.note !== 'string') throw new Error('note 必须是字符串');
+  const note = entry.note.trim();
+  if (!note) throw new Error('note 不能为空');
+  if (note.length > MAX_NOTE_LENGTH) throw new Error(`note 不能超过 ${MAX_NOTE_LENGTH} 个字符`);
+
+  return {
+    id,
+    note,
+    tags: entry.tags === undefined ? undefined : normalizeTags(entry.tags),
+    autoEnable: entry.autoEnable === undefined ? undefined : normalizeAutoEnable(entry.autoEnable, label)
+  };
+}
+
+function normalizeTags(tags) {
+  if (!Array.isArray(tags)) throw new Error('tags 必须是字符串数组');
+  const normalized = [];
+  for (const tag of tags) {
+    if (typeof tag !== 'string') throw new Error('tags 只能包含字符串');
+    const value = tag.trim();
+    if (!value) continue;
+    if (value.length > MAX_TAG_LENGTH) throw new Error(`tag 不能超过 ${MAX_TAG_LENGTH} 个字符: ${value}`);
+    if (!normalized.includes(value)) normalized.push(value);
+  }
+  if (normalized.length > MAX_TAGS) throw new Error(`tags 不能超过 ${MAX_TAGS} 个`);
+  return normalized;
+}
+
+function normalizeAutoEnable(value) {
+  if (typeof value !== 'boolean') throw new Error('autoEnable 必须是布尔值');
+  return value;
+}
+
+function metadataMatches(skill, payload) {
+  return String(skill.note || '').trim() === payload.note
+    && Boolean(skill.autoEnable ?? true) === payload.autoEnable
+    && JSON.stringify(skill.tags || []) === JSON.stringify(payload.tags);
+}
+
+async function executePlan(plan, options = {}) {
+  if (!options.yes) return { dryRun: true, updated: 0, failed: 0 };
+
+  let updated = 0;
+  let failed = 0;
+  for (const change of plan.changes) {
+    try {
+      await (options.postMetadata || postMetadata)(options.port, change.payload);
+      process.stderr.write(`✓ ${change.id}\n`);
+      updated += 1;
+    } catch (error) {
+      process.stderr.write(`✗ ${change.id}: ${error.message}\n`);
+      failed += 1;
+    }
+  }
+  return { dryRun: false, updated, failed };
+}
+
+function printPlan(plan) {
+  process.stderr.write(`目标库: ${plan.libraryRoot}\n`);
+  process.stderr.write(`计划更新: ${plan.changes.length}，无需更新: ${plan.unchanged.length}\n`);
+  plan.changes.forEach((change) => process.stderr.write(`- ${change.id}\n`));
+}
+
+async function listCommand(opts) {
+  const state = await fetchState(opts.port, opts.project);
+  const manifest = createTranslationManifest(state);
+  process.stdout.write(`${JSON.stringify(manifest, null, 2)}\n`);
+  process.stderr.write(`待翻译: ${manifest.entries.length} 个 skill\n`);
+}
+
+async function applyCommand(opts) {
+  if (!opts.file) throw new Error('apply 需要 manifest 文件路径');
+  const manifest = parseManifest(fs.readFileSync(path.resolve(opts.file), 'utf8'));
+  const state = await fetchState(opts.port, opts.project);
+  const plan = preflightManifest(manifest, state, { forceRewrite: opts.forceRewrite });
+  printPlan(plan);
+
+  const result = await executePlan(plan, {
+    yes: opts.yes,
+    port: opts.port
+  });
+  if (result.dryRun) {
+    process.stderr.write('仅完成预检，未写入；确认后加 --yes 执行。\n');
+  } else {
+    process.stderr.write(`完成: 成功 ${result.updated}，失败 ${result.failed}\n`);
+  }
+  return result.failed > 0 ? 1 : 0;
+}
+
+function printUsage() {
+  process.stderr.write('用法:\n');
+  process.stderr.write('  node skills/skillcaddy-manager/scripts/translate-skill-notes.cjs list [--port=4173] [--project=.]\n');
+  process.stderr.write('  node skills/skillcaddy-manager/scripts/translate-skill-notes.cjs apply <manifest.json> [--yes] [--force-rewrite]\n');
+}
+
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const opts = parseArgs(argv);
+    if (opts.command === 'list') await listCommand(opts);
+    else if (opts.command === 'apply') return applyCommand(opts);
+    else {
+      printUsage();
+      return 2;
+    }
+    return 0;
+  } catch (error) {
+    process.stderr.write(`错误: ${error.message}\n`);
+    return 1;
+  }
+}
+
+module.exports = {
+  createTranslationManifest,
+  executePlan,
+  isMostlyChinese,
+  main,
+  needsTranslation,
+  parseArgs,
+  parseManifest,
+  preflightManifest
+};
+
+if (require.main === module) {
+  main().then((code) => {
+    process.exitCode = code;
+  });
+}