@yottameta/yotta-skills-plugin 0.6.1 → 0.6.2

package/.agents/plugins/marketplace.json

@@ -12,7 +12,7 @@
         "authentication": "ON_INSTALL"
       },
       "category": "Developer Tools",
-      "version": "0.6.1",
+      "version": "0.6.2",
       "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
       "interface": {
         "displayName": "元阁 yotta-skills",

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
         "authentication": "ON_INSTALL"
       },
       "category": "Developer Tools",
-      "version": "0.6.1",
+      "version": "0.6.2",
       "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
       "interface": {
         "displayName": "元阁 yotta-skills",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-skills-plugin",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "YuanGe (元阁) — orchestration and routing for the YottaMeta skill family, packaged as a YottaMeta Agent Plugin.",
   "license": "MIT",
   "keywords": [

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "yotta-skills",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
   "author": {
     "name": "YottaMeta",

package/skills/yotta-skills/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: yotta-skills
-version: 0.6.1
-description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么自动装+自动用」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录；盘点层：--inventory / --reindex 扫描本机已装技能生成/更新注册表，新装技能自动被发现（install/update 后自动 re-index，会话开工可先跑 --reindex；自包含零依赖，不依赖任何元技能）；MCP 按需加载（可选：list_installed_skills/describe_skill/reindex/route_request，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / install / update / --inventory / --reindex / --dry-run 预览 / --pin 锁版本。触发：需要批量安装或更新元阁全家技能、按场景组合多个元技能、路由或判断该用哪些技能、盘点或查看本机已装技能、重扫技能注册表、给某个智能体或目录一次性铺齐 yotta-* 技能、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/该用哪个技能/路由技能/盘点技能/查看已装技能 等。边界（Do NOT trigger）：只做「组合策划 + 静态路由建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能；装前摘要仅供参考，安装决策由用户确认。
+version: 0.6.2
+description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么自动装+自动用」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录；盘点层：--inventory / --reindex 扫描本机已装技能生成/更新注册表，新装技能自动被发现（install/update 后自动 re-index，会话开工可先跑 --reindex 与 update --check（联网只读检查更新）；自包含零依赖，不依赖任何元技能）；MCP 按需加载（可选：list_installed_skills/describe_skill/reindex/route_request，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / install / update / update --check（只读检查）/ update --auto（家族自动更新）/ --inventory / --reindex / --dry-run 预览 / --pin 锁版本。触发：需要批量安装或更新元阁全家技能、按场景组合多个元技能、路由或判断该用哪些技能、盘点或查看本机已装技能、重扫技能注册表、给某个智能体或目录一次性铺齐 yotta-* 技能、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/检查更新/自动更新/该用哪个技能/路由技能/盘点技能/查看已装技能 等。边界（Do NOT trigger）：只做「组合策划 + 静态路由建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能；装前摘要仅供参考，安装决策由用户确认。
 license: MIT
 metadata:
   zh_name: 元阁
@@ -16,7 +16,8 @@ metadata:
 **写入内容（逐字）**：
 
 > **元阁编排**：单技能是零件，组合才是系统。会话开工先跑一次 `yotta-skills --reindex`
-> （重扫本机技能注册表，新装技能自动被看见）。接到需求，先查「元阁编排策划」命中哪个组合
+> （重扫本机技能注册表，新装技能自动被看见）；会话开工再跑一次 `yotta-skills update --check`
+> （联网只读检查本地已装技能是否有更新；有更新列清单，确认后 `update`，或 `update --auto` 仅自动更新自家 yotta-* 家族）。接到需求，先查「元阁编排策划」命中哪个组合
 > （输出呈现标准 / 长生命周期 / 交付质量门 / 装前安全门 / 造技能发版 / 安全事件响应 / 入口安装），
 > 再按需自动安装并应用。完整决策表见技能 `yotta-skills/references/orchestration.md`。
 
@@ -31,7 +32,7 @@ metadata:
 
 - **路由层（该用哪几个）**：`--route "<需求摘要>"` / MCP `route_request` 查本地注册表与静态编排 playbook，输出候选组合、调用顺序、每个技能角色、置信度、依据、已装/缺失状态与安装命令；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；只建议安装，不自动安装。
 - **策划层（怎么用）**：接到需求，先按「编排策划」定位命中哪个组合——哪些元技能搭配起来最强、适合什么场景、AI 该怎么自动装并自动用起来。
-- **安装层（怎么装）**：一条 `npx -y @yottameta/yotta-skills` 把组合/全家装进指定智能体或目录——`--list` 看清单、`install` 装、`update` 增量更新、`--dry-run` 预览、`--pin` 锁版本。
+- **安装层（怎么装）**：一条 `npx -y @yottameta/yotta-skills` 把组合/全家装进指定智能体或目录——`--list` 看清单、`install` 装、`update` 增量更新、`update --check` 只读检查更新、`update --auto` 家族自动更新、`--dry-run` 预览、`--pin` 锁版本。
 - **盘点层（已装了什么）**：`--inventory` / `--reindex` 扫描本机各智能体技能目录，生成/更新本地注册表；装技能后自动 re-index，新装技能自动被发现——自包含扫描，不依赖任何元技能。
 
 每个技能仍走各自独立的 npm 包（版本源唯一）；本包只做「清单 + 下载 + 落位 + 汇总」，**不内置任何技能本体**。
@@ -97,6 +98,12 @@ npx -y @yottameta/yotta-skills install yotta-memory yotta-verify --dir ~/my-skil
 # 增量更新已装技能（补齐缺失 / 版本不一致）
 npx -y @yottameta/yotta-skills update --agent codex
 
+# 只读检查有没有更新（联网对 npm 最新，不改动；0=全部最新 / 3=有更新 / 1=查失败）
+npx -y @yottameta/yotta-skills update --check --agent codex
+
+# 检查到家族更新后自动更新（仅 yotta-* 自家家族，含装前安全扫描）
+npx -y @yottameta/yotta-skills update --auto --agent codex
+
 # 预览将安装清单（不联网、不改动）
 npx -y @yottameta/yotta-skills --dry-run
 
@@ -116,6 +123,8 @@ npx -y @yottameta/yotta-skills --reindex
 | `install --dir <path>` | 装全家到指定目录，每个技能落在 `<path>/<slug>` |
 | `install <skill>... [--agent <name> \| --dir <path>]` | 只装指定的一个或多个技能 |
 | `update [--agent <name> \| --dir <path>]` | 增量更新：补齐缺失技能、升级版本不一致的技能 |
+| `update --check [--agent <name> \| --dir <path>]` | 只读检查更新：联网对 npm 最新，不改动；退出码 0=全部最新 / 3=有更新 / 1=查失败 |
+| `update --auto [--agent <name> \| --dir <path>]` | 检查到家族更新后自动更新（仅 yotta-* 自家家族，含装前安全扫描） |
 | `--inventory` | 盘点本机已装技能：扫描技能目录生成/更新注册表（自包含，不依赖元技能）；`--json` 输出 JSON、`--project` 附扫项目级目录 |
 | `--reindex` | 重扫注册表：扫描技能目录并增量合并变化（会话开工 / 装技能后自动调用）；`--json` 输出 JSON、`--project` 附扫项目级目录；`--rescan` 同义 |
 | `--route <需求摘要>` | 静态编排路由：输出组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装建议；`--json` 输出 JSON、`--project` 附扫项目级目录 |
@@ -158,6 +167,22 @@ npx -y @yottameta/yotta-skills --inventory --dir ~/my-skills --project
   让新装 / 更新的技能自动进入注册表。
 - **手动**：`yotta-skills --reindex`（`--rescan` 同义）；`--json` 机器可读、`--project` 附扫项目级目录。
 
+### update 增量更新与检查（--check / --auto）
+
+增量更新遍历清单，补齐缺失、升级版本不一致，默认跳过已最新。`--check` 只读联网
+（对 npm `dist-tags.latest`），按本地 `SKILL.md` 版本对比——无论技能源自哪个安装渠道
+（npm / git clone / 本地拷贝等）都兼容；`--auto` 检测到家族（`yotta-*` / 清单内）可更新时，走安装管线
+（含元信装前安全扫描）自动更新。**非元阁家族（非 yotta-*）技能绝不自动更新**（默认保守：`--check` 列清单，
+用户确认后再 `update`）。
+
+```bash
+# 只读检查（0=全部最新 / 3=有更新 / 1=查失败）
+npx -y @yottameta/yotta-skills update --check --agent codex
+
+# 检查到家族更新后自动更新（仅自家家族）
+npx -y @yottameta/yotta-skills update --auto --agent codex
+```
+
 ## 编排路由（--route）
 
 把需求摘要交给静态编排 playbook 和本地注册表，得到一组可执行建议：

package/skills/yotta-skills/bin/yotta-skills.js

@@ -8,6 +8,8 @@
  *   npx -y @yottameta/yotta-skills install --dir <path>   # 装全家到指定目录
  *   npx -y @yottameta/yotta-skills install <skill> --dir <path>  # 装单个技能
  *   npx -y @yottameta/yotta-skills update --agent <name>  # 增量更新已装技能（补齐缺失/版本不一致）
+ *   npx -y @yottameta/yotta-skills update --check         # 只读检查更新（联网对 npm 最新，不改动；退出码 0/3/1）
+ *   npx -y @yottameta/yotta-skills update --auto          # 检查到家族更新后自动更新（仅 yotta-* 家族，含装前扫描）
  *   npx -y @yottameta/yotta-skills --dry-run              # 预览将安装清单（不联网、不改动）
  *
  * 版本策略：清单锁定 `major.x`（不锁死 patch，维护性更新随最新）；--pin 锁死精确版本。
@@ -20,6 +22,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { spawnSync } = require('child_process');
+const http = require('http');
+const https = require('https');
 
 const PKG_ROOT = path.join(__dirname, '..');
 let VERSION = '0.2.1';
@@ -132,6 +136,7 @@ function parseArgs(argv) {
     help: false, version: false, agent: null, dir: null, npm: null,
     python: null, verify: null, command: null, skill: null, rest: [],
     inventory: false, reindex: false, noReindex: false, json: false, project: false, route: null,
+    check: false, auto: false, registry: null,
   };
   const positionals = [];
   for (let i = 0; i < argv.length; i++) {
@@ -160,6 +165,9 @@ function parseArgs(argv) {
     else if (a === '--npm') opts.npm = take('--npm');
     else if (a === '--python') opts.python = take('--python');
     else if (a === '--verify') opts.verify = take('--verify');
+    else if (a === '--check') opts.check = true;
+    else if (a === '--auto') opts.auto = true;
+    else if (a === '--registry') opts.registry = take('--registry');
     else if (a.startsWith('-')) die('未知参数: ' + a);
     else positionals.push(a);
   }
@@ -208,6 +216,147 @@ function readInstalledVersion(dir) {
   } catch (_) { return null; }
 }
 
+
+// ── 更新检查（只读）与自动更新 ─────────────────────────────────────────────
+function registryUrl(pkg, registry) {
+  var base = (registry || process.env.YOTTA_SKILLS_REGISTRY || 'https://registry.npmjs.org/').replace(/\/$/, '');
+  return base + '/' + pkg.replace(/\//g, '%2f');
+}
+
+function fetchRegistryLatest(pkg, opts) {
+  return new Promise(function (resolve) {
+    var url = registryUrl(pkg, opts.registry);
+    var client = url.startsWith('https:') ? https : http;
+    var req = client.get(url, { timeout: 15000, headers: { 'accept': 'application/json', 'user-agent': 'yotta-skills-check' } }, function (res) {
+      var data = '';
+      res.setEncoding('utf8');
+      res.on('data', function (c) { data += c; });
+      res.on('end', function () {
+        try {
+          var j = JSON.parse(data);
+          var latest = j && j['dist-tags'] && j['dist-tags'].latest;
+          if (!latest) { resolve({ ok: false, error: '响应缺少 dist-tags.latest（' + pkg + '）' }); return; }
+          resolve({ ok: true, version: latest });
+        } catch (e) {
+          resolve({ ok: false, error: '解析 registry 响应失败: ' + e.message });
+        }
+      });
+    });
+    req.on('error', function (e) { resolve({ ok: false, error: '网络错误: ' + (e && e.message ? e.message : e) }); });
+    req.on('timeout', function () { req.destroy(); resolve({ ok: false, error: '网络超时（15s）' }); });
+  });
+}
+
+function readInstalledMeta(dir) {
+  var f = path.join(dir, 'SKILL.md');
+  try {
+    var text = fs.readFileSync(f, 'utf8');
+    var name = (text.match(/^name:\s*(.+)$/m) || [])[1];
+    var version = (text.match(/^version:\s*([0-9]+\.[0-9]+\.[0-9]+)/m) || [])[1];
+    return { name: name ? name.trim() : null, version: version || null };
+  } catch (e) { return { name: null, version: null }; }
+}
+
+function familySkillFor(slug) {
+  var m = findSkill(slug);
+  if (m) return m;
+  if (/^yotta-/.test(slug)) {
+    return { slug: slug, name: slug.replace(/^yotta-/, ''), pkg: '@yottameta/' + slug, version: null, desc: '推断的家族技能（不在 skills.json 清单）' };
+  }
+  return null;
+}
+
+function scanInstalledSlugs(dest) {
+  var list = [];
+  var entries;
+  try { entries = fs.readdirSync(dest, { withFileTypes: true }); } catch (e) { return list; }
+  for (var i = 0; i < entries.length; i++) {
+    var e = entries[i];
+    if (!e.isDirectory()) continue;
+    var meta = readInstalledMeta(path.join(dest, e.name));
+    if (meta.name) list.push({ slug: e.name, name: meta.name, version: meta.version });
+  }
+  return list;
+}
+
+async function runUpdateCheck(opts, dest) {
+  var lines = [];
+  var quiet = !!opts.json;
+  function say(s) { if (!quiet) lines.push(s); }
+  say('yotta-skills（元阁）v' + VERSION + ' —— 检查更新（只读，不改动） -> ' + dest);
+  say('版本源: ' + (opts.registry || process.env.YOTTA_SKILLS_REGISTRY || 'https://registry.npmjs.org/'));
+  say('');
+  var installed = scanInstalledSlugs(dest);
+  if (installed.length === 0) {
+    say('（' + dest + ' 下未发现已装技能目录）');
+    return { code: 0, rows: [], updates: 0, latest: 0, failed: 0, nonFamily: 0 };
+  }
+  var rows = [];
+  var updates = 0, latest = 0, failed = 0, nonFamily = 0;
+  for (var i = 0; i < installed.length; i++) {
+    var it = installed[i];
+    var fam = familySkillFor(it.slug);
+    if (!fam) {
+      nonFamily++;
+      say('  - ' + it.slug.padEnd(22) + '非元阁家族，跳过');
+      continue;
+    }
+    var res = await fetchRegistryLatest(fam.pkg, opts);
+    if (!res.ok) {
+      failed++;
+      say('  ✘ ' + it.slug.padEnd(22) + '检查失败: ' + res.error);
+      continue;
+    }
+    var current = res.version;
+    var cur = it.version || null;
+    var isUp = (cur === current);
+    if (isUp) {
+      latest++;
+      say('  ✔ ' + it.slug.padEnd(22) + '已最新（本地 v' + cur + '）');
+    } else {
+      updates++;
+      say('  ➤ ' + it.slug.padEnd(22) + '有更新：本地 v' + (cur || '未知') + ' -> 最新 v' + current);
+      if (fam.version && fam.version !== current) {
+        say('       ⚠ 清单 skills.json 记为 v' + fam.version + '，与 npm 最新 v' + current + ' 不一致（需同步清单）');
+      }
+    }
+    rows.push({ slug: it.slug, installed: cur, latest: current, pkg: fam.pkg, hasUpdate: !isUp, family: fam });
+  }
+  say('');
+  say('汇总: 有更新 ' + updates + ' / 已最新 ' + latest + ' / 检查失败 ' + failed + ' / 非家族跳过 ' + nonFamily);
+  for (var j = 0; j < lines.length; j++) out(lines[j]);
+  var code = (failed > 0) ? 1 : (updates > 0 ? 3 : 0);
+  return { code: code, rows: rows, updates: updates, latest: latest, failed: failed, nonFamily: nonFamily };
+}
+
+async function runUpdateAuto(opts, dest) {
+  out('yotta-skills（元阁）v' + VERSION + ' —— 检查并自动更新（仅 yotta-* 家族） -> ' + dest);
+  var r = await runUpdateCheck(Object.assign({}, opts, { json: false }), dest);
+  if (r.failed > 0) {
+    out('检查未完成（' + r.failed + ' 个失败），未自动更新；可先排查网络后重试。');
+    return { code: 1 };
+  }
+  if (r.updates === 0) {
+    out('全部已最新，无需更新。');
+    return { code: 0 };
+  }
+  out('');
+  out('检测到 ' + r.updates + ' 个家族技能可更新，开始自动更新（安装管线，含装前安全扫描）：');
+  var ok = 0, failed2 = 0;
+  for (var i = 0; i < r.rows.length; i++) {
+    var row = r.rows[i];
+    if (!row.hasUpdate) continue;
+    var res = installOne(Object.assign({}, row.family, { version: row.latest }), dest, Object.assign({}, opts, { force: true, pin: true }));
+    if (res.status === 'ok') ok++;
+    else if (res.status === 'skip') ok++;
+    else failed2++;
+  }
+  out('');
+  out('自动更新汇总: 成功 ' + ok + ' / 失败 ' + failed2);
+  maybeAutoReindex(opts, dest);
+  return { code: failed2 > 0 ? 1 : 0 };
+}
+
 function shouldSkip(name, isFile) {
   if (name === '__pycache__' || name === '.pytest_cache' || name === '.mypy_cache') return true;
   if (isFile && (name.endsWith('.pyc') || name.endsWith('.pyo'))) return true;
@@ -458,6 +607,9 @@ function printHelp() {
   out('  --verify <path>  指定 yotta_verify.py 路径（默认找目标目录已装的元信）');
   out('  --json            inventory / reindex / route 时输出 JSON');
   out('  --route <需求>    静态编排路由（输出组合 / 顺序 / 依据 / 缺失技能建议）');
+  out('  --check            update 时仅只读检查更新（联网对 npm 最新版本，不改动；退出码 0/3/1）');
+  out('  --auto             update 时检查到家族更新后自动更新（仅 yotta-* 家族，含装前扫描）');
+  out('  --registry <url>  npm registry 地址（默认 https://registry.npmjs.org/；YOTTA_SKILLS_REGISTRY 覆盖）');
   out('  --project         inventory / reindex 时附加扫描当前项目 .agents/skills / .codex/skills');
   out('  --no-reindex      安装 / 更新后不自动重扫注册表');
   out('  -h, --help       帮助');
@@ -614,9 +766,23 @@ function main() {
     return;
   }
 
-  if (command === 'update') runUpdate(opts, dest);
-  else runInstall(opts, dest);
-  maybeAutoReindex(opts, dest);
+  if (command === 'update') {
+    if (opts.check || opts.auto) {
+      var runFn = opts.auto ? runUpdateAuto : runUpdateCheck;
+      runFn(opts, dest).then(function (r) {
+        if (opts.json && !opts.auto) {
+          out(JSON.stringify({ dest: dest, updatable: r.rows.filter(function (x) { return x.hasUpdate; }), updates: r.updates, latest: r.latest, failed: r.failed, nonFamily: r.nonFamily }, null, 2));
+        }
+        process.exitCode = r.code;
+      });
+    } else {
+      runUpdate(opts, dest);
+      maybeAutoReindex(opts, dest);
+    }
+  } else {
+    runInstall(opts, dest);
+    maybeAutoReindex(opts, dest);
+  }
 }
 
 main();

package/skills/yotta-skills/scripts/yotta-skills-mcp.py

@@ -24,7 +24,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-VERSION = "0.6.1"
+VERSION = "0.6.2"
 TOOL_NAME = "yotta-skills"
 CN_NAME = "元阁"
 MCP_PROTOCOL_MODERN = "2026-07-28"