ygc-dsh-sync 1.3.2 → 1.3.4

package/client.js

@@ -151,6 +151,20 @@ function makePanel(React) {
       }
     }, []);
 
+    // `refresh` 是面板里多处 `await refresh()` 用到的名字。
+    // 1.2.x 一直没有定义过它（那些调用全落在 ReferenceError 上，被 catch 吞成
+    // 「操作失败」），本机在改这一栏时才发现。这里给它一个明确的实现：
+    // 重新拉一次 /state，顺带把待批草稿数与归属摘要刷一遍（都是轻量请求）。
+    const refresh = useCallback(async () => {
+      await load();
+      try {
+        const lr = await call('/skills/learning/list', {});
+        if (mounted.current) setLearningList(lr.items || []);
+      } catch {
+        /* 待批草稿读不到不影响主状态 */
+      }
+    }, [load]);
+
     useEffect(() => {
       mounted.current = true;
       load();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ygc-dsh-sync",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "type": "module",
   "description": "DSH 同步插件：会话按工作区落地、按机器隔离的跨机备份与拉取；技能进特征文件夹（整棵备份 + 说明 + 来源 + 更新时间），跨机只读拉取、同名不覆盖改走学习评估；本机技能优化（精炼 / 精简 / 合并重复 / 补工况 / 补踩坑 / 修死引用）；技能市场装的第三方技能不管理、不同步、不优化。母版功能已取消。",
   "icon": "icon.svg",

package/tools/_health.mjs

@@ -1,24 +1,105 @@
+/**
+ * 技能健康检查（1.3.x）：母版取消后，这份脚本只回答「本机这一侧现在怎么样」。
+ *
+ * 原来它拿母版跟本机做 planSync 对比。母版功能已取消，那套对比没有意义了，
+ * 换成三件在 1.3.x 里真正会发生的事：
+ *   1. 归属：哪些技能归本插件管、哪些是市场第三方（不同步、不优化）
+ *   2. 体检：自研技能的机械问题分布
+ *   3. 特征本：自己的技能备份是否已经写出去、有多少、多大
+ *
+ * 用法：node tools/_health.mjs [--json]
+ */
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { planSync } from '../lib/skills.js';
 
-const MASTER = 'D:\\Ai工作空间\\技能库';
-const LOCAL = path.join(os.homedir(), '.agents', 'skills');
+const { ownNames, scopeSnapshot } = await import('../lib/skill-scope.js');
+const { inspectAll } = await import('../lib/skill-optimize.js');
+const { mySkillsRoot, SKILLS_INDEX } = await import('../lib/skillshare.js');
 
-console.log('母版路径存在:', fs.existsSync(MASTER));
-if (fs.existsSync(MASTER)) {
-  const dirs = fs.readdirSync(MASTER, { withFileTypes: true }).filter((d) => d.isDirectory());
-  console.log('母版子目录数:', dirs.length);
-  const withSkill = dirs.filter((d) => fs.existsSync(path.join(MASTER, d.name, 'SKILL.md')));
-  console.log('含 SKILL.md:', withSkill.length);
+const LOCAL = process.env.DSH_SYNC_SKILLS_ROOT
+  ? path.resolve(process.env.DSH_SYNC_SKILLS_ROOT)
+  : path.join(os.homedir(), '.agents', 'skills');
+
+const STATE = process.env.DSH_SYNC_STATE_FILE
+  ? path.resolve(process.env.DSH_SYNC_STATE_FILE)
+  : path.join(os.homedir(), '.dsh', 'storages', 'sync-backup.json');
+
+let state = {};
+try {
+  state = JSON.parse(fs.readFileSync(STATE, 'utf8'));
+} catch {
+  state = {};
+}
+const machineId = state.machineId || '';
+const libraryRoot = (state.plugins && state.plugins.libraryRoot) || 'D:\\Ai工作空间\\插件库';
+const config = { libraryRoot };
+
+const wantJson = process.argv.includes('--json');
+const out = {};
+
+// ── 1. 归属
+const scope = scopeSnapshot({ localRoot: LOCAL, overrides: (state.skills && state.skills.share && state.skills.share.scope) || {} });
+out.scope = scope;
+const own = ownNames({ localRoot: LOCAL, overrides: (state.skills && state.skills.share && state.skills.share.scope) || {} });
+
+// ── 2. 体检
+const insp = inspectAll({ localRoot: LOCAL, ownSet: own.names });
+out.inspect = {
+  scanned: insp.scanned,
+  healthy: insp.healthy,
+  thirdPartySkipped: insp.thirdParty,
+  issues: insp.items.length,
+  top: insp.items.slice(0, 10).map((x) => ({ skill: x.name, score: x.score, action: x.action, codes: x.issues.map((i) => i.code).join(',') })),
+  codes: insp.codes,
+};
+
+// ── 3. 特征本
+const root = machineId ? mySkillsRoot(config, machineId) : '';
+const indexFile = root ? path.join(root, SKILLS_INDEX) : '';
+let index = null;
+try {
+  index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+} catch {
+  index = null;
 }
+out.feature = {
+  machineId,
+  root,
+  exists: Boolean(root && fs.existsSync(root)),
+  indexed: index ? index.counts : null,
+  generatedAt: index ? index.generatedAt : '',
+};
+
+if (wantJson) {
+  console.log(JSON.stringify(out, null, 2));
+} else {
+  console.log('== 归属 ==');
+  console.log(`  本机技能根: ${LOCAL}`);
+  console.log(`  自研 ${scope.counts.own} · 第三方 ${scope.counts.thirdParty} · 待确认 ${scope.counts.weak}`);
+  console.log(`  证据: 市场台账 ${scope.evidence.ledger.count} 条（${scope.evidence.ledger.ok ? '读到' : '读不到'}）`);
+  if (scope.thirdParty.length) {
+    console.log(`  前 8 个第三方: ${scope.thirdParty.slice(0, 8).map((x) => x.name).join(', ')}`);
+  }
 
-const p = planSync({ masterRoot: MASTER, localRoot: LOCAL, modes: {} });
-console.log('\nplanSync 结果:');
-console.log('  母版:', p.master.size);
-console.log('  本地:', p.local.size);
-console.log('  待拉取:', p.pull.length);
-console.log('  待推送:', p.push.length, p.push.map((x) => x.name).join(', ') || '-');
-console.log('  一致:', p.same.length);
-console.log('  本机独有:', p.localOnly.length, p.localOnly.map((x) => x.name).join(', ') || '-');
+  console.log('');
+  console.log('== 体检 ==');
+  console.log(`  扫到 ${insp.scanned} 个（健康 ${insp.healthy}，第三方跳过 ${insp.thirdParty}），有问题 ${insp.items.length} 个`);
+  const codeList = Object.entries(insp.codes).sort((a, b) => b[1] - a[1]);
+  if (codeList.length) console.log(`  问题分布: ${codeList.map(([c, n]) => `${c}×${n}`).join('  ')}`);
+  for (const x of out.inspect.top) console.log(`  - ${x.skill}（分 ${x.score}，建议 ${x.action}）`);
+
+  console.log('');
+  console.log('== 特征本 ==');
+  if (!machineId) {
+    console.log('  本机标识还没生成，跳过');
+  } else {
+    console.log(`  目录: ${root}`);
+    console.log(`  存在: ${out.feature.exists ? '是' : '否（下次同步会建）'}`);
+    if (index) {
+      console.log(`  索引: ${index.counts.total} 个技能 · ${(index.counts.bytes / 1048576).toFixed(1)} MB · ${index.generatedAt}`);
+    } else {
+      console.log('  索引: 还没写（下次同步会写）');
+    }
+  }
+}

package/tools/skill-lineage.mjs

@@ -1,243 +1,161 @@
 /**
- * 技能比对 / 谱系维护工具。
+ * 技能谱系维护工具（1.3.x 重写）。
  *
- * 解决什么问题：
- *   dsh-mnemon 采纳演化草稿时直接改 SKILL.md，**不动 version**。同步插件原来
- *   只看 version，两边都写 1.0.0 但内容不同就一律卡在「待确认」。
+ * ## 它现在做什么
  *
- * 现在按**内容修改时间**判（不是文件 mtime——同步会刷它）：
- *   谱系文件 `~/.dsh/storages/...` 旁的 `<母版>/.skill-lineage.json` 记着
- *   「两侧各自的内容何时变成现在这样」。谁晚谁是新版；只有一侧变过时，
- *   变的那侧就是最新的。
+ * 母版取消后，技能的「谁更新」不再是「母版 vs 本机」两方问题，而是
+ * 「我这格 vs 别人那格」多方问题。判据随之简化成一条：**内容指纹**。
+ * 时间戳只作展示（NAS 会刷 mtime），这一点在 1.2.x 已经踩过。
  *
- * 用法：
- *   node tools/skill-lineage.mjs --status                 只看判定（不写任何文件）
- *   node tools/skill-lineage.mjs                          比对 + 自动同步（同面板）
- *   node tools/skill-lineage.mjs --dry                    只比对不同步
- *   node tools/skill-lineage.mjs --init                   把两侧一致的登记为基线
- *   node tools/skill-lineage.mjs --init --force           冲突项也按「母版为准」登记
- *   node tools/skill-lineage.mjs --reset                  清空谱系（自动备份旧文件）
+ * 这个工具只保留两件在 1.3.x 里还有意义的事：
+ *   1. `--status`  打印本机 vs 各台机器的技能分布（只读）
+ *   2. `--backfill` 给缺 version 的自研技能补一个（原 add-version 的能力）
  *
- * 默认母版路径读 ~/.dsh/storages/sync-backup.json 的 skills.masterRoot。
+ * 原来的 `--init/--force/--reset`（母版谱系基线）随母版一并取消：
+ * `.skill-lineage.json` 不再被任何判定读取，留着只会让人以为它还有用。
+ *
+ * ## 用法
+ *
+ * ```bash
+ * node tools/skill-lineage.mjs --status
+ * node tools/skill-lineage.mjs --backfill --dry
+ * node tools/skill-lineage.mjs --backfill
+ * ```
  */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import {
-  LINEAGE_FILE,
-  LOCAL_SKILLS_ROOT,
-  applyPull,
-  applyPush,
-  buildHistoryIndex,
-  loadLineage,
-  makeStamp,
-  planSync,
-  readMnemonLedger,
-  recordLineage,
-  saveLineage,
-  judgeUpdate,
-  scanSkills,
-} from '../lib/skills.js';
-import { readChangelogTimes } from '../lib/changelog.js';
 
-const STATE_FILE = process.env.DSH_SYNC_STATE_FILE
+const args = process.argv.slice(2);
+const has = (f) => args.includes(f);
+
+const STATE = process.env.DSH_SYNC_STATE_FILE
   ? path.resolve(process.env.DSH_SYNC_STATE_FILE)
   : path.join(os.homedir(), '.dsh', 'storages', 'sync-backup.json');
+const LOCAL = process.env.DSH_SYNC_SKILLS_ROOT
+  ? path.resolve(process.env.DSH_SYNC_SKILLS_ROOT)
+  : path.join(os.homedir(), '.agents', 'skills');
+
+let state = {};
+try {
+  state = JSON.parse(fs.readFileSync(STATE, 'utf8'));
+} catch {
+  state = {};
+}
+const machineId = state.machineId || '';
+const libraryRoot = (state.plugins && state.plugins.libraryRoot) || 'D:\\Ai工作空间\\插件库';
+const overrides = (state.skills && state.skills.share && state.skills.share.scope) || {};
+const config = { libraryRoot };
 
-const args = process.argv.slice(2);
-const has = (flag) => args.includes(flag);
-const valOf = (flag) => {
-  const i = args.indexOf(flag);
-  return i >= 0 && args[i + 1] ? args[i + 1] : '';
-};
+/* ------------------------------------------------------------ --status */
 
-function masterRoot() {
-  const explicit = valOf('--master');
-  if (explicit) return explicit;
+async function status() {
+  const { ownNames } = await import('../lib/skill-scope.js');
+  const { collectSharedSkills, mySkillsRoot, SKILLS_INDEX } = await import('../lib/skillshare.js');
+
+  const own = ownNames({ localRoot: LOCAL, overrides });
+  const collected = collectSharedSkills({ config, machineId, localRoot: LOCAL, only: own.names });
+  const root = machineId ? mySkillsRoot(config, machineId) : '';
+  let index = null;
   try {
-    const s = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
-    return (s.skills && s.skills.masterRoot) || '';
+    index = JSON.parse(fs.readFileSync(path.join(root, SKILLS_INDEX), 'utf8'));
   } catch {
-    return '';
+    index = null;
   }
-}
 
-const master = masterRoot();
-if (!master) {
-  console.error('没有母版路径：用 --master <路径> 指定，或先在插件里设置技能母版文件夹。');
-  process.exit(2);
-}
-if (!fs.existsSync(master)) {
-  console.error(`母版路径不存在：${master}`);
-  process.exit(2);
-}
+  console.log('== 本机 ==');
+  console.log(`  技能根      ${LOCAL}`);
+  console.log(`  特征格      ${root || '(标识未生成)'}`);
+  console.log(`  自研        ${own.names.size} 个`);
+  console.log(`  第三方      ${own.thirdParty.length} 个（不同步、不优化）`);
+  console.log(`  索引        ${index ? `${index.counts.total} 个 · ${(index.counts.bytes / 1048576).toFixed(1)} MB` : '还没写'}`);
 
-const localRoot = valOf('--local') || LOCAL_SKILLS_ROOT;
-const lineagePath = path.join(master, LINEAGE_FILE);
-const VERDICT_LABEL = { master: '母版新', local: '本机新', unknown: '待你决定', same: '一致' };
-
-/* ------------------------------------------------------------ 只看状态 */
-
-if (has('--status')) {
-  const lineage = loadLineage(lineagePath);
-  const ledger = readMnemonLedger();
-  const history = buildHistoryIndex({ masterRoot: master, localRoot, changelogTimes: readChangelogTimes(master) });
-  const m = scanSkills(master);
-  const l = scanSkills(localRoot);
-  const names = [...new Set([...m.keys(), ...l.keys()])].sort();
-
-  const rows = [];
-  for (const name of names) {
-    const mm = m.get(name);
-    const ll = l.get(name);
-    if (!mm || !ll) continue;
-    if (mm.treeHash === ll.treeHash) {
-      rows.push({ name, verdict: 'same', basis: '-', hint: '两侧内容相同' });
-      continue;
+  console.log('');
+  console.log('== 各台机器 ==');
+  if (!collected.sources.length) {
+    console.log('  （插件库里还没有任何技能层）');
+  } else {
+    for (const s of collected.sources) {
+      console.log(`  ${s.feature}${s.mine ? '（本机）' : ''}  ${s.total} 个 · ${s.generatedAt || '-'}`);
     }
-    const j = judgeUpdate({ name, master: mm, local: ll, record: lineage[name], ledger, history });
-    rows.push({ name, verdict: j.verdict, basis: j.basis || '-', hint: j.detail });
   }
 
-  const byVerdict = rows.reduce((acc, r) => {
-    acc[r.verdict] = (acc[r.verdict] || 0) + 1;
-    return acc;
-  }, {});
-
-  console.log(`母版：${master}`);
-  console.log(`本机：${localRoot}`);
-  console.log(`谱系：${fs.existsSync(lineagePath) ? `${Object.keys(lineage).length} 条观测` : '还没建'}`);
-  console.log(`账本：${ledger.size} 个技能有记忆插件记录`);
-  console.log('');
-  console.log(
-    Object.entries(byVerdict)
-      .map(([k, v]) => `${VERDICT_LABEL[k] || k} ${v}`)
-      .join(' · ') || '没有可比技能',
-  );
   console.log('');
-  for (const r of rows) {
-    if (has('--brief') && r.verdict === 'same') continue;
-    console.log(`${(VERDICT_LABEL[r.verdict] || r.verdict).padEnd(5)} ${r.name.padEnd(34)} [${r.basis}] ${r.hint}`);
+  console.log('== 与本机的关系 ==');
+  console.log(`  一致        ${collected.same.length}`);
+  console.log(`  本机缺      ${collected.missing.length}${collected.missing.length ? `：${collected.missing.slice(0, 8).map((x) => x.name).join(', ')}` : ''}`);
+  console.log(`  内容不同    ${collected.differ.length}${collected.differ.length ? `：${collected.differ.slice(0, 8).map((x) => x.name).join(', ')}` : ''}`);
+  console.log(`  他人第三方  ${collected.thirdParty.length}（本机不拉）`);
+  if (collected.warnings.length) {
+    console.log('');
+    console.log('提示：');
+    for (const w of collected.warnings.slice(0, 6)) console.log(`  - ${w}`);
   }
-  process.exit(0);
+  console.log('');
+  console.log('下一步：面板「优化本机技能」出草稿；「立即共享」把本机备份出去并拉缺失。');
 }
 
-/* ------------------------------------------------------------ 建基线 */
+/* ---------------------------------------------------------- --backfill */
 
-if (has('--reset')) {
-  if (fs.existsSync(lineagePath)) {
-    const bak = `${lineagePath}.bak-${Date.now()}`;
-    fs.renameSync(lineagePath, bak);
-    console.log(`已移除谱系文件，旧文件备份为 ${path.basename(bak)}`);
-  } else {
-    console.log('谱系文件本来就不存在。');
+/**
+ * 给缺 version 的技能补一个 `version: 1.0.0`。
+ *
+ * 只改 front matter，保留原编码（UTF-8 BOM 原样）与换行风格；
+ * 已有 version 的一律跳过，不覆盖别人的版本号。
+ */
+function backfill({ dryRun }) {
+  const IGNORED = /^(__pycache__|node_modules|\.git)$/;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(LOCAL, { withFileTypes: true });
+  } catch {
+    console.error(`读不到技能根：${LOCAL}`);
+    process.exit(2);
   }
-  process.exit(0);
-}
-
-if (has('--init')) {
-  const only = valOf('--names')
-    .split(',')
-    .map((s) => s.trim())
-    .filter(Boolean);
-  const force = has('--force');
-
-  const m = scanSkills(master);
-  const l = scanSkills(localRoot);
-  const lineage = loadLineage(lineagePath);
-
-  const registered = [];
-  const skipped = [];
-
-  for (const name of [...m.keys()].sort()) {
-    if (only.length && !only.includes(name)) continue;
-    const mm = m.get(name);
-    const ll = l.get(name);
-    if (!ll) {
-      skipped.push({ name, why: '本机没有' });
+  let touched = 0;
+  let skipped = 0;
+  for (const e of entries) {
+    if (!e.isDirectory() || e.name.startsWith('.') || e.name.startsWith('_') || IGNORED.test(e.name)) continue;
+    const file = path.join(LOCAL, e.name, 'SKILL.md');
+    let raw;
+    try {
+      raw = fs.readFileSync(file, 'utf8');
+    } catch {
       continue;
     }
-    if (mm.treeHash !== ll.treeHash && !force) {
-      skipped.push({ name, why: '两侧内容不同，先比对/同步再说' });
+    const bom = raw.charCodeAt(0) === 0xfeff ? '\ufeff' : '';
+    const body = bom ? raw.slice(1) : raw;
+    const m = body.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!m) {
+      skipped += 1;
       continue;
     }
-    registered.push({ name, src: mm });
-  }
-
-  let map = lineage;
-  for (const r of registered) {
-    map = recordLineage(map, {
-      name: r.name,
-      baseline: r.src.treeHash,
-      master: r.src,
-      local: r.src,
-      by: `baseline:${os.hostname()}`,
-    });
-  }
-  const ok = saveLineage(lineagePath, map);
-
-  console.log(`谱系文件：${lineagePath}`);
-  console.log(`${ok ? '已登记' : '写入失败'} ${registered.length} 个技能`);
-  if (registered.length) console.log(`   ${registered.map((r) => r.name).join(', ')}`);
-  if (skipped.length) {
-    console.log(`跳过 ${skipped.length} 个：`);
-    for (const s of skipped) console.log(`   ${s.name} — ${s.why}`);
+    if (/^version\s*:/m.test(m[1])) {
+      skipped += 1;
+      continue;
+    }
+    const eol = /\r\n/.test(body) ? '\r\n' : '\n';
+    const nextFm = `${m[1]}${eol}version: 1.0.0`;
+    const out = `${bom}${body.slice(0, m.index)}---${eol}${nextFm}${eol}---${body.slice(m.index + m[0].length)}`;
+    if (dryRun) {
+      console.log(`  would add version: ${e.name}`);
+    } else {
+      fs.writeFileSync(file, out, 'utf8');
+      console.log(`  added version: ${e.name}`);
+    }
+    touched += 1;
   }
-  process.exit(ok ? 0 : 1);
+  console.log('');
+  console.log(`${dryRun ? '预演' : '完成'}：处理 ${touched} 个，跳过 ${skipped} 个（已有 version 或无 frontmatter）`);
 }
 
-/* ------------------------------------------------- 默认：比对（可自动同步） */
-
-const dry = has('--dry');
-const plan = planSync({
-  masterRoot: master,
-  localRoot,
-  modes: {},
-  lineage: loadLineage(lineagePath),
-  mnemonLedger: readMnemonLedger(),
-  history: buildHistoryIndex({ masterRoot: master, localRoot, changelogTimes: readChangelogTimes(master) }),
-});
+/* -------------------------------------------------------------- 入口 */
 
-const stamp = makeStamp();
-const pulled = dry || !plan.pull.length ? { pulled: [], errors: [] } : applyPull({ items: plan.pull, localRoot, stamp });
-const pushed =
-  dry || !plan.autoPush.length
-    ? { pushed: [], errors: [] }
-    : applyPush({ items: plan.autoPush, masterRoot: master, backRoot: path.join(master, '_backup'), stamp });
-
-// 记观测 + 基线
-{
-  let map = loadLineage(lineagePath);
-  const now = Date.now();
-  for (const [name, m] of plan.master) {
-    const l = plan.local.get(name);
-    if (!l) continue;
-    map = recordLineage(map, {
-      name,
-      ...(m.treeHash === l.treeHash ? { baseline: m.treeHash } : {}),
-      master: m,
-      local: l,
-      by: `cli:${os.hostname()}`,
-      at: now,
-    });
-  }
-  const aligned = [...plan.pull.map((x) => x.master), ...plan.autoPush.map((x) => x.local), ...plan.same.map((x) => x.master)].filter(Boolean);
-  for (const x of aligned) map = recordLineage(map, { name: x.name, baseline: x.treeHash, master: x, local: x, at: now });
-  if (!dry) saveLineage(lineagePath, map);
-}
-
-console.log(`母版：${master}`);
-console.log(`本机：${localRoot}`);
-console.log('');
-if (dry) {
-  console.log(`[只比对] 母版新 ${plan.pull.length}、本机新 ${plan.autoPush.length}、待你决定 ${plan.push.length}、一致 ${plan.same.length}`);
+if (has('--backfill')) {
+  backfill({ dryRun: has('--dry') });
+} else if (has('--status') || args.length === 0) {
+  await status();
 } else {
-  console.log(
-    `已自动拉取 ${pulled.pulled.length}、已自动推送 ${pushed.pushed.length}、待你决定 ${plan.push.length}、一致 ${plan.same.length}`,
-  );
+  console.error('未知参数。可用：--status（默认）、--backfill [--dry]');
+  process.exit(2);
 }
-for (const x of plan.pull) console.log(`  拉  ${x.name} [${x.basis || 'new'}] ${x.reason || ''}`);
-for (const x of plan.autoPush) console.log(`  推  ${x.name} [${x.basis || '-'}] ${x.reason}`);
-for (const x of plan.push) console.log(`  判  ${x.name} [${x.basis || '-'}] ${x.reason}`);
-for (const e of [...pulled.errors, ...pushed.errors]) console.log(`  !! ${e.name}: ${e.message}`);
-process.exit(0);