@matrixfu/skill-set-manager 0.0.0-stage → 1.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/client.js +1618 -0
- package/cordis.patch.yml +5 -0
- package/icon.svg +7 -0
- package/index.js +1091 -0
- package/lib/core/atomic.js +16 -0
- package/lib/core/backup.js +123 -0
- package/lib/core/binding.js +22 -0
- package/lib/core/commandLine.js +31 -0
- package/lib/core/dataPlane.js +81 -0
- package/lib/core/diagnose.js +167 -0
- package/lib/core/effective.js +237 -0
- package/lib/core/giterr.js +22 -0
- package/lib/core/github.js +256 -0
- package/lib/core/gitignore.js +35 -0
- package/lib/core/gitnet.js +112 -0
- package/lib/core/lifecycle.js +88 -0
- package/lib/core/linkx.js +92 -0
- package/lib/core/managed.js +24 -0
- package/lib/core/manifest.js +169 -0
- package/lib/core/migrate.js +145 -0
- package/lib/core/opgate.js +62 -0
- package/lib/core/paths.js +52 -0
- package/lib/core/pending.js +210 -0
- package/lib/core/plan.js +33 -0
- package/lib/core/projectRoot.js +20 -0
- package/lib/core/providerSkills.js +26 -0
- package/lib/core/provision.js +32 -0
- package/lib/core/resident.js +98 -0
- package/lib/core/resolver.js +136 -0
- package/lib/core/search.js +28 -0
- package/lib/core/sets.js +250 -0
- package/lib/core/source.js +64 -0
- package/lib/core/storage.js +87 -0
- package/lib/core/translateExec.js +122 -0
- package/lib/core/translations.js +62 -0
- package/lib/core/updates.js +181 -0
- package/locale/en.json +6 -0
- package/locale/zh.json +6 -0
- package/package.json +63 -4
- package/README.md +0 -3
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 长任务闸门(GLOSSARY「长任务」):host 侧单飞 + 最近结果留存 + 写盘后的 `/` 菜单失效事件。
|
|
3
|
+
*
|
|
4
|
+
* 收口前这两条不变式都不在 host:单飞只存在于 client.js 的 tasks 表(关掉界面或换入口就没有闸门,
|
|
5
|
+
* Remote / fetch 兜底同一实现但无人互斥),失效事件散在 12 个调用点自行记得——于是 installApply /
|
|
6
|
+
* updateApply / importApply 装完不发事件(`/` 菜单仍是旧的),而 uninstallSkill / migrate* 发。
|
|
7
|
+
*/
|
|
8
|
+
export function createOpGate({ onMutated = null } = {}) {
|
|
9
|
+
const state = { seq: 0, running: null, last: null };
|
|
10
|
+
|
|
11
|
+
const snapshot = (task) => (task ? {
|
|
12
|
+
id: task.id, name: task.name, target: task.target, status: task.status,
|
|
13
|
+
startedAt: task.startedAt, doneAt: task.doneAt,
|
|
14
|
+
result: task.result ?? null, error: task.error ?? null, warnings: task.warnings ?? null,
|
|
15
|
+
} : null);
|
|
16
|
+
|
|
17
|
+
const status = () => ({ running: snapshot(state.running), last: snapshot(state.last) });
|
|
18
|
+
|
|
19
|
+
/** 被挡住时点名在跑的是谁:Remote 桥不保证保留自定义字段,故文本前缀也带 BUSY。 */
|
|
20
|
+
const busyError = (running) => {
|
|
21
|
+
const err = new Error(`BUSY: ${[running.name, running.target].filter(Boolean).join(' ')}`);
|
|
22
|
+
err.code = 'BUSY';
|
|
23
|
+
err.running = snapshot(running);
|
|
24
|
+
return err;
|
|
25
|
+
};
|
|
26
|
+
|
|
27
|
+
/**
|
|
28
|
+
* 长任务:全局单飞;成功即发失效事件(mutates: false 的只读任务不发)。
|
|
29
|
+
* 失败不吞——原样抛出,但最近结果如实记 err,界面据此说明。
|
|
30
|
+
*/
|
|
31
|
+
async function run(name, meta, fn) {
|
|
32
|
+
if (state.running) throw busyError(state.running);
|
|
33
|
+
const task = {
|
|
34
|
+
id: (state.seq += 1), name, target: meta?.target ?? null, status: 'running',
|
|
35
|
+
startedAt: Date.now(), doneAt: null, result: null, error: null, warnings: [],
|
|
36
|
+
};
|
|
37
|
+
state.running = task; state.last = task;
|
|
38
|
+
try {
|
|
39
|
+
const value = await fn();
|
|
40
|
+
task.status = 'ok'; task.doneAt = Date.now();
|
|
41
|
+
task.result = value ?? null;
|
|
42
|
+
task.warnings = Array.isArray(value?.warnings) ? value.warnings : [];
|
|
43
|
+
if (meta?.mutates !== false && onMutated) onMutated();
|
|
44
|
+
return value;
|
|
45
|
+
} catch (e) {
|
|
46
|
+
task.status = 'err'; task.doneAt = Date.now(); task.error = String(e?.message ?? e);
|
|
47
|
+
throw e;
|
|
48
|
+
} finally { state.running = null; }
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/** 短写:无单飞,但「成功落盘 → 失效事件」由这里保证,调用方无从漏发。 */
|
|
52
|
+
async function mutate(fn) {
|
|
53
|
+
const value = await fn();
|
|
54
|
+
if (onMutated) onMutated();
|
|
55
|
+
return value;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** 条件写(只有真改了才发):事件机制仍收在这里,条件留在调用方。 */
|
|
59
|
+
const touch = () => { if (onMutated) onMutated(); };
|
|
60
|
+
|
|
61
|
+
return { run, mutate, touch, status, isBusy: () => !!state.running };
|
|
62
|
+
}
|
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
/** 根路径装配与常量。纯数据,无 IO。 */
|
|
2
|
+
import path from 'node:path';
|
|
3
|
+
import os from 'node:os';
|
|
4
|
+
|
|
5
|
+
/** 技能名(=目录名/引用名)必须 kebab-case(§7.3)。 */
|
|
6
|
+
export const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
|
|
7
|
+
/** 扫描层优先级:数字小者胜(与 dsh-skill-filesystem 的 rank 一致)。 */
|
|
8
|
+
export const ZONE_RANKS = {
|
|
9
|
+
'project-dsh': 100,
|
|
10
|
+
'project-agents': 200,
|
|
11
|
+
custom: 300,
|
|
12
|
+
'user-dsh': 400,
|
|
13
|
+
'user-agents': 500,
|
|
14
|
+
bundled: 600,
|
|
15
|
+
};
|
|
16
|
+
|
|
17
|
+
export function defaultDshHome() {
|
|
18
|
+
return process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
|
|
19
|
+
}
|
|
20
|
+
export function defaultAgentsHome() {
|
|
21
|
+
return process.env.DSH_AGENTS_HOME || path.join(os.homedir(), '.agents');
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
/**
|
|
25
|
+
* 项目生效目录(2026-10-30 迁移):`<projectRoot>/.agents/skills`。
|
|
26
|
+
* 与 DSH 扫描层 `project-agents`(rank 200)同址,且是各 harness 共享的项目技能目录,
|
|
27
|
+
* 因此技能集条目在 DSH 之外的智能体软件里同样可见;旧的 `<projectRoot>/.dsh/skills`
|
|
28
|
+
* (rank 100)不再由插件写入。全部读写入口统一走本函数,避免路径口径漂移。
|
|
29
|
+
*/
|
|
30
|
+
export function projectSkillsDir(projectRoot) {
|
|
31
|
+
return path.join(projectRoot, '.agents', 'skills');
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
/** 显式装配全部根;生产 apply() 与验收脚本都走这里(core 不读 env)。 */
|
|
35
|
+
export function buildRoots({ dshHome, agentsHome, customSkillDirs = [], crossHarnessResident = false } = {}) {
|
|
36
|
+
dshHome = path.resolve(dshHome ?? defaultDshHome());
|
|
37
|
+
agentsHome = path.resolve(agentsHome ?? defaultAgentsHome());
|
|
38
|
+
return {
|
|
39
|
+
dshHome,
|
|
40
|
+
agentsHome,
|
|
41
|
+
libraryRoot: path.join(dshHome, 'skill-library'), // 生效区之外(§4.2)
|
|
42
|
+
setsDir: path.join(dshHome, 'skill-sets'),
|
|
43
|
+
// 上游缓存(GLOSSARY「上游缓存」:传输层复用,不改「检查=问最新」语义)与失败留痕
|
|
44
|
+
cacheDir: path.join(dshHome, 'skill-set-manager', 'cache'),
|
|
45
|
+
failLog: path.join(dshHome, 'skill-set-manager', 'failures.log'),
|
|
46
|
+
userDshRoot: path.join(dshHome, 'skills'),
|
|
47
|
+
userAgentsRoot: path.join(agentsHome, 'skills'),
|
|
48
|
+
// 常驻链接目标区(P3 搬迁:默认 = 跨 harness 区 ~/.agents/skills;开关开 = 额外保留旧 ~/.dsh/skills)
|
|
49
|
+
globalResidentDirs: [path.join(agentsHome, 'skills'), ...(crossHarnessResident ? [path.join(dshHome, 'skills')] : [])],
|
|
50
|
+
customDirs: customSkillDirs.map((d) => path.resolve(d)),
|
|
51
|
+
};
|
|
52
|
+
}
|
|
@@ -0,0 +1,210 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 会话临时覆盖(§6.6):先落 pending 标记再动目录;崩溃残留由启动 restoreAllPending
|
|
3
|
+
* **无条件**还原(按 binding 重放 planEffective+applyPlan)——这是「直接写」设计的前提。
|
|
4
|
+
* 未绑定项目也可起盘覆盖(台账 setSlug 为 null),还原后回到插件零写入(设计 2026-10-28)。
|
|
5
|
+
* undo 快照供技能集切换的一次性撤销(§5.2),消费即删。
|
|
6
|
+
*/
|
|
7
|
+
import fs from 'node:fs';
|
|
8
|
+
import path from 'node:path';
|
|
9
|
+
import { projectKey } from './storage.js';
|
|
10
|
+
import { readManaged, writeManaged, managedFile } from './managed.js';
|
|
11
|
+
import { readBinding, writeBinding } from './binding.js';
|
|
12
|
+
import { converge } from './effective.js';
|
|
13
|
+
import { loadSet, RESIDENT_SLUG } from './sets.js';
|
|
14
|
+
import { resolveSkillTargets } from './resolver.js';
|
|
15
|
+
import { makeEntry, removeEntry, entryKind } from './linkx.js';
|
|
16
|
+
import { projectSkillsDir } from './paths.js';
|
|
17
|
+
|
|
18
|
+
/**
|
|
19
|
+
* 净覆盖口径:台账 ∖ 集 = added;集 ∖ 台账 = removed。每次 startOverride 全量重算写回,
|
|
20
|
+
* 连续覆盖自然累计合并(用户报:先加 c 再摘 b,第二次把记录整个替换成 {added:[],removed:[b]},
|
|
21
|
+
* c 失去归属 → 自检误报「多出」红标);对历史丢记录的状态也起自纠作用。
|
|
22
|
+
* 冻结(集已删):基线未知无法算净差——退回「前记录 ∪ 本次」累计,冻结还原分支据 added 精确回收(review M9)。
|
|
23
|
+
*/
|
|
24
|
+
function netOverride(roots, setSlug, entries, prev, { addedThisCall = [], removedThisCall = [] } = {}) {
|
|
25
|
+
const resident = !setSlug || setSlug === RESIDENT_SLUG;
|
|
26
|
+
const setDoc = resident ? null : loadSet(roots, setSlug);
|
|
27
|
+
if (!resident && !setDoc)
|
|
28
|
+
return {
|
|
29
|
+
added: [...new Set([...(prev?.added ?? []), ...addedThisCall])],
|
|
30
|
+
removed: [...new Set([...(prev?.removed ?? []), ...removedThisCall])],
|
|
31
|
+
};
|
|
32
|
+
const base = new Set(setDoc?.skills ?? []); // 常驻绑定:项目目录基线本就为空(§5.3)
|
|
33
|
+
const cur = new Set(Object.keys(entries));
|
|
34
|
+
return { added: [...cur].filter((n) => !base.has(n)), removed: [...base].filter((n) => !cur.has(n)) };
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
export async function startOverride(store, roots, projectRoot, { add = [], remove = [], sessionId = null } = {}, { fs: fsImpl = fs } = {}) {
|
|
38
|
+
const managed = readManaged(projectRoot, { fs: fsImpl }) ?? { setSlug: null, entries: {}, sessionOverride: null }; // 未绑定也可起盘:台账 setSlug 为 null(设计 2026-10-28)
|
|
39
|
+
const snapshot = { setSlug: managed.setSlug, entries: structuredClone(managed.entries), sessionOverride: managed.sessionOverride };
|
|
40
|
+
const skillsDir = projectSkillsDir(projectRoot);
|
|
41
|
+
// 未绑定起盘时若该目录原本不存在,还原后连这个空目录一起收回(回到插件零写入)
|
|
42
|
+
const createdSkillsDir = !fsImpl.existsSync(skillsDir);
|
|
43
|
+
// 先落标记后动目录(§6.6 崩溃即设计前提):标记在 = 可还原;目录动了没标记 = 不可还原
|
|
44
|
+
// sessionId = 本次覆盖的归属会话(§6.6「只对本次会话生效」):事件还原据此判断是否该动手(评审 I1)
|
|
45
|
+
const rec = (added, removed) => ({ projectRoot, setSlug: managed.setSlug, sessionId: sessionId ?? null, previousManaged: snapshot, added, removed, createdSkillsDir });
|
|
46
|
+
await store.put('pending', projectKey(projectRoot), rec([], []));
|
|
47
|
+
const entries = { ...managed.entries };
|
|
48
|
+
const removed = remove.filter((n) => n in entries);
|
|
49
|
+
for (const name of removed) {
|
|
50
|
+
removeEntry(path.join(skillsDir, name), entries[name].kind, { fs: fsImpl });
|
|
51
|
+
delete entries[name];
|
|
52
|
+
}
|
|
53
|
+
const added = [];
|
|
54
|
+
const missingAdd = [];
|
|
55
|
+
if (add.length) {
|
|
56
|
+
const { targets } = await resolveSkillTargets(roots, projectRoot, add, { fs: fsImpl });
|
|
57
|
+
for (const name of add) {
|
|
58
|
+
const t = targets.get(name);
|
|
59
|
+
if (!t) { missingAdd.push(name); continue; }
|
|
60
|
+
if (entryKind(path.join(skillsDir, name), { fs: fsImpl }) !== 'missing') { missingAdd.push(name); continue; } // 同名外来条目:不抢占(§7.3)
|
|
61
|
+
const made = makeEntry(t.path, path.join(skillsDir, name), { fs: fsImpl });
|
|
62
|
+
entries[name] = { kind: made.kind, from: t.origin ?? t.path, ...(made.copied ? { copied: true } : {}), ...(made.flat ? { flat: true } : {}) };
|
|
63
|
+
added.push(name);
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
// 先写标记后动目录的反序风险取「先落标记」:标记在 = 可还原;目录动了没标记 = 不可还原
|
|
67
|
+
writeManaged(projectRoot, { setSlug: managed.setSlug, entries, sessionOverride: netOverride(roots, managed.setSlug, entries, managed.sessionOverride, { addedThisCall: added, removedThisCall: removed }) }, { fs: fsImpl });
|
|
68
|
+
await store.put('pending', projectKey(projectRoot), rec(added, removed));
|
|
69
|
+
return { ...snapshot, missingAdd };
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/**
|
|
73
|
+
* 绑定即丢弃会话覆盖(设计 2026-10-28):只有**当前仍未绑定**且存在覆盖记录时清标记——
|
|
74
|
+
* 未绑定时临时勾的技能不该粘进新绑定的集。已绑定之间切换仍保留覆盖(现状口径)。
|
|
75
|
+
* 必须在 `writeBinding` 之前调用:判定「绑定前是不是未绑定」靠的就是当时的 binding。
|
|
76
|
+
*/
|
|
77
|
+
export function dropOverrideOnBind(projectRoot, { fs: fsImpl = fs } = {}) {
|
|
78
|
+
if (readBinding(projectRoot, { fs: fsImpl })?.setSlug) return false; // 已绑定:切换保留覆盖
|
|
79
|
+
const managed = readManaged(projectRoot, { fs: fsImpl });
|
|
80
|
+
if (!managed?.sessionOverride) return false;
|
|
81
|
+
writeManaged(projectRoot, { ...managed, sessionOverride: null }, { fs: fsImpl });
|
|
82
|
+
return true;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/** 手动结束覆盖:按 binding 还原目录,清标记(面板按钮=用户明示意图,无条件执行)。 */
|
|
86
|
+
export async function endOverride(store, roots, projectRoot) {
|
|
87
|
+
const key = projectKey(projectRoot);
|
|
88
|
+
const rec = await store.get('pending', key);
|
|
89
|
+
if (!rec) return false;
|
|
90
|
+
const restored = await restoreProject(roots, rec.projectRoot, rec);
|
|
91
|
+
await store.delete('pending', key);
|
|
92
|
+
return restored; // 已解绑/冻结无可还原目标:如实返回,标记照样清掉
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
/**
|
|
96
|
+
* 事件级还原(§6.6 P2):会话结束/归档时**有 pending 标记才动手**——
|
|
97
|
+
* 真相源是 pending 记录(startOverride 先落标记后动目录),因此对未覆盖项目零副作用。
|
|
98
|
+
* 无标记时不动目录也不写文件,事件可以每个会话都挂而不用担心误伤。
|
|
99
|
+
* **归属判定(评审 I1)**:记录带 sessionId 且与本次结束的会话不同 → 跳过;
|
|
100
|
+
* 旧记录(无 sessionId)或拿不到结束会话 id 时按 P1 口径照还原。
|
|
101
|
+
*/
|
|
102
|
+
export async function endOverrideIfActive(store, roots, projectRoot, endingSessionId = null) {
|
|
103
|
+
const rec = await store.get('pending', projectKey(projectRoot));
|
|
104
|
+
if (!rec) return { ended: false };
|
|
105
|
+
if (rec.sessionId && endingSessionId && rec.sessionId !== endingSessionId)
|
|
106
|
+
return { ended: false, skipped: 'other-session', projectRoot, ownerSession: rec.sessionId };
|
|
107
|
+
const ended = await endOverride(store, roots, projectRoot);
|
|
108
|
+
return { ended: !!ended, projectRoot };
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
/**
|
|
112
|
+
* 未绑定还原(设计 2026-10-28):本次覆盖加了什么就摘什么;台账空了连 `.managed.json`
|
|
113
|
+
* 一起删,本次创建的空 `.agents/skills` 目录也收回——项目回到「插件零写入」。
|
|
114
|
+
* 未绑定基线为空 ⇒ sessionOverride.removed 恒为空,无需补回条目。
|
|
115
|
+
*/
|
|
116
|
+
function unboundRestore(projectRoot, rec) {
|
|
117
|
+
const mg = readManaged(projectRoot);
|
|
118
|
+
if (!mg?.sessionOverride) return false; // 没有覆盖痕迹:不动盘
|
|
119
|
+
const skillsDir = projectSkillsDir(projectRoot);
|
|
120
|
+
for (const n of mg.sessionOverride.added ?? []) {
|
|
121
|
+
const kind = mg.entries?.[n]?.kind;
|
|
122
|
+
if (kind) removeEntry(path.join(skillsDir, n), kind);
|
|
123
|
+
if (mg.entries) delete mg.entries[n];
|
|
124
|
+
}
|
|
125
|
+
if (Object.keys(mg.entries ?? {}).length) { writeManaged(projectRoot, { ...mg, sessionOverride: null }); return true; }
|
|
126
|
+
fs.rmSync(managedFile(projectRoot), { force: true });
|
|
127
|
+
if (rec?.createdSkillsDir) { try { if (fs.readdirSync(skillsDir).length === 0) fs.rmdirSync(skillsDir); } catch {} }
|
|
128
|
+
return true;
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
async function restoreProject(roots, projectRoot, rec = null) {
|
|
132
|
+
const binding = readBinding(projectRoot);
|
|
133
|
+
if (!binding?.setSlug) return unboundRestore(projectRoot, rec); // 未绑定/已解绑:只收回本次覆盖加的条目
|
|
134
|
+
// 冻结绑定(集已删,§5.8「清单原样保留」):不按空清单重放(那会摘光托管条目,评审 M9);
|
|
135
|
+
// 只摘本次覆盖加的条目,其余条目与台账原样留着,等用户改名/重建集。
|
|
136
|
+
if (binding.setSlug !== RESIDENT_SLUG && !loadSet(roots, binding.setSlug)) {
|
|
137
|
+
const mg = readManaged(projectRoot);
|
|
138
|
+
if (mg?.sessionOverride) {
|
|
139
|
+
const skillsDir = projectSkillsDir(projectRoot);
|
|
140
|
+
for (const n of mg.sessionOverride.added ?? []) {
|
|
141
|
+
const kind = mg.entries?.[n]?.kind;
|
|
142
|
+
if (kind) removeEntry(path.join(skillsDir, n), kind);
|
|
143
|
+
if (mg.entries) delete mg.entries[n];
|
|
144
|
+
}
|
|
145
|
+
writeManaged(projectRoot, { ...mg, sessionOverride: null });
|
|
146
|
+
}
|
|
147
|
+
return false;
|
|
148
|
+
}
|
|
149
|
+
// 还原=放弃会话覆盖回到绑定态:先清 sessionOverride 标记再收敛盘,否则
|
|
150
|
+
// planEffective 按覆盖口径收敛、覆盖标记与盘面互相矛盾(活体口径教训)。
|
|
151
|
+
const managed = readManaged(projectRoot);
|
|
152
|
+
if (managed && managed.sessionOverride) writeManaged(projectRoot, { ...managed, sessionOverride: null });
|
|
153
|
+
await converge(roots, projectRoot, binding.setSlug);
|
|
154
|
+
return true;
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
/** 启动无条件扫描(§6.6:崩溃即设计前提,不做「是否本会话」判断)。 */
|
|
158
|
+
export async function restoreAllPending(store, roots) {
|
|
159
|
+
const restored = [];
|
|
160
|
+
const warnings = [];
|
|
161
|
+
for (const key of await store.keys('pending')) {
|
|
162
|
+
const rec = await store.get('pending', key);
|
|
163
|
+
if (!rec) continue;
|
|
164
|
+
try {
|
|
165
|
+
if (await restoreProject(roots, rec.projectRoot, rec)) restored.push(rec.projectRoot);
|
|
166
|
+
} catch (e) {
|
|
167
|
+
warnings.push(`${rec.projectRoot}: 启动还原失败(${e.message})`);
|
|
168
|
+
continue; // 保留标记,下次启动再试
|
|
169
|
+
}
|
|
170
|
+
await store.delete('pending', key);
|
|
171
|
+
}
|
|
172
|
+
return { restored, warnings };
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
/** 切换前快照(binding + managed);一次性:applyUndo 消费即删。 */
|
|
176
|
+
export async function pushUndo(store, roots, projectRoot) {
|
|
177
|
+
const binding = readBinding(projectRoot);
|
|
178
|
+
if (!binding) return null;
|
|
179
|
+
const managed = readManaged(projectRoot);
|
|
180
|
+
const snap = {
|
|
181
|
+
projectRoot,
|
|
182
|
+
setSlug: binding.setSlug,
|
|
183
|
+
managed: managed ? { entries: managed.entries, sessionOverride: managed.sessionOverride } : null,
|
|
184
|
+
pushedAt: new Date().toISOString(),
|
|
185
|
+
};
|
|
186
|
+
await store.put('undo', projectKey(projectRoot), snap);
|
|
187
|
+
return snap;
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
export async function popUndo(store, projectRoot) {
|
|
191
|
+
const key = projectKey(projectRoot);
|
|
192
|
+
const snap = await store.get('undo', key);
|
|
193
|
+
if (snap) await store.delete('undo', key);
|
|
194
|
+
return snap;
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
/** 撤销 = 还原 binding 并重放该集生效清单(目录回到切换态)。 */
|
|
198
|
+
export async function applyUndo(store, roots, projectRoot) {
|
|
199
|
+
const snap = await popUndo(store, projectRoot);
|
|
200
|
+
if (!snap) return false;
|
|
201
|
+
if (snap.setSlug) {
|
|
202
|
+
writeBinding(projectRoot, snap.setSlug);
|
|
203
|
+
// 先回写快照台账(含其 sessionOverride),再按快照口径收敛盘——顺序颠倒
|
|
204
|
+
// 会让 planEffective 读到撤销前的覆盖标记、还原不出快照里的条目。
|
|
205
|
+
const mg = snap.managed ? { setSlug: snap.setSlug, entries: snap.managed.entries ?? {}, sessionOverride: snap.managed.sessionOverride ?? null } : null;
|
|
206
|
+
if (mg) writeManaged(projectRoot, mg);
|
|
207
|
+
await converge(roots, projectRoot, snap.setSlug);
|
|
208
|
+
}
|
|
209
|
+
return true;
|
|
210
|
+
}
|
package/lib/core/plan.js
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 「期望名 → 盘面差异」的唯一算法(架构评审候选 3)。
|
|
3
|
+
*
|
|
4
|
+
* 常驻区(resident.js,台账 = 每目录一份 links 记录)与项目生效区(effective.js,
|
|
5
|
+
* 台账 = .managed.json 的 entries)此前各写一遍同样的五分类:
|
|
6
|
+
* - 台账在 · 盘在 → 保持(resident 仍会重跑 makeEntry:那是「先摘再建」的修复语义)
|
|
7
|
+
* - 台账在 · 盘没了 → 重建(外删/死链,review M1)
|
|
8
|
+
* - 台账无 · 盘上有 → 外来:警告,不抢占不删除(ADR-0003)
|
|
9
|
+
* - 解析不到 → 悬空:警告,不落盘(§7.4)
|
|
10
|
+
* - 台账有 · 期望无 → 摘除
|
|
11
|
+
* 两个区的 apply 差异是领域差异(常驻区无台账文件、项目区有 copied/flat 标记),不在此处参数化。
|
|
12
|
+
*/
|
|
13
|
+
export function diffPlan({ names, ledger = {}, resolve, probe }) {
|
|
14
|
+
const add = [];
|
|
15
|
+
const keep = [];
|
|
16
|
+
const warnMissing = [];
|
|
17
|
+
const warnForeign = [];
|
|
18
|
+
for (const name of names) {
|
|
19
|
+
const target = resolve(name);
|
|
20
|
+
if (!target) { warnMissing.push(name); continue; }
|
|
21
|
+
const disk = probe(name);
|
|
22
|
+
if (name in ledger) {
|
|
23
|
+
if (disk.onDisk) { keep.push(name); continue; }
|
|
24
|
+
add.push({ name, ...target });
|
|
25
|
+
continue;
|
|
26
|
+
}
|
|
27
|
+
if (disk.onDisk) { warnForeign.push({ name, kind: disk.kind }); continue; }
|
|
28
|
+
add.push({ name, ...target });
|
|
29
|
+
}
|
|
30
|
+
const wanted = new Set(names);
|
|
31
|
+
const remove = Object.keys(ledger).filter((n) => !wanted.has(n)).map((n) => ({ name: n, kind: ledger[n].kind }));
|
|
32
|
+
return { add, remove, keep, warnMissing, warnForeign };
|
|
33
|
+
}
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 项目根解析(§4.5):照抄平台——最近的含 .git 祖先目录(目录或 worktree 文件都算),
|
|
3
|
+
* 否则退回会话目录本身。插件不自算第二套。
|
|
4
|
+
*/
|
|
5
|
+
import fs from 'node:fs';
|
|
6
|
+
import path from 'node:path';
|
|
7
|
+
|
|
8
|
+
export function findProjectRoot(startDir, { fs: fsImpl = fs } = {}) {
|
|
9
|
+
const start = path.resolve(startDir);
|
|
10
|
+
let dir = start;
|
|
11
|
+
for (;;) {
|
|
12
|
+
try {
|
|
13
|
+
const marker = fsImpl.statSync(path.join(dir, '.git')); // stat 跟随:.git 目录或文件都算
|
|
14
|
+
if (marker) return dir;
|
|
15
|
+
} catch { /* 无 .git,继续向上 */ }
|
|
16
|
+
const parent = path.dirname(dir);
|
|
17
|
+
if (parent === dir) return start; // 到盘根仍无版本库:退回会话目录本身(§4.5)
|
|
18
|
+
dir = parent;
|
|
19
|
+
}
|
|
20
|
+
}
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 插件/Preset 提供技能的枚举(用户疑问 2026-10-26:选了技能集为何仍见 /archify、/office-docx)。
|
|
3
|
+
* 这类技能由插件 Skill 提供者或 agent preset 运行时注入,不在生效区盘上,插件无法经目录
|
|
4
|
+
* 感知;唯一可见口径 = 平台 skills 服务的清单(探针事实:ctx.get('skills') + list({cwd}),
|
|
5
|
+
* provider 字段即提供者名)。排除口径 = 生效清单(常驻 ∪ 集)+ 托管台账 + 常驻名单。
|
|
6
|
+
* 库名**不**作排除:库在生效区之外,未生效的库名根本不会出现在清单里;而「库里有同名
|
|
7
|
+
* 本体但此刻未生效」的技能(如 archify 在库、当前集未选)仍由插件提供者注入生效,
|
|
8
|
+
* 必须留在本区如实呈现。服务缺席(headless/未挂载)返回 null = 不可知,
|
|
9
|
+
* 调用方不得把 null 当空集。术语见 GLOSSARY「插件提供(Plugin-provided)」。
|
|
10
|
+
*/
|
|
11
|
+
|
|
12
|
+
// provider 命中这些名字的技能来自文件系统扫描区(生效区/常驻区),不是插件注入,不列。
|
|
13
|
+
const FILESYSTEM_PROVIDERS = new Set(['filesystem', 'runtime']);
|
|
14
|
+
|
|
15
|
+
export async function providerSkills({ skillsService, projectRoot, managedEntries = {} }, { effectiveNames = [], residentNames = [] } = {}) {
|
|
16
|
+
if (!skillsService || typeof skillsService.list !== 'function' || !projectRoot) return null;
|
|
17
|
+
const exclude = new Set([...effectiveNames, ...residentNames, ...Object.keys(managedEntries)]);
|
|
18
|
+
const list = await skillsService.list({ cwd: projectRoot });
|
|
19
|
+
const seen = new Set();
|
|
20
|
+
return (Array.isArray(list) ? list : [])
|
|
21
|
+
.filter((s) => s && typeof s.name === 'string' && !exclude.has(s.name))
|
|
22
|
+
.filter((s) => !FILESYSTEM_PROVIDERS.has(String(s.provider ?? '')))
|
|
23
|
+
.map((s) => ({ name: s.name, provider: String(s.provider ?? s.source ?? 'unknown'), source: typeof s.source === 'string' ? s.source : null }))
|
|
24
|
+
.filter((s) => (seen.has(s.name) ? false : seen.add(s.name)))
|
|
25
|
+
.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
|
|
26
|
+
}
|
|
@@ -0,0 +1,32 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 绑定写点(§5.2 切换 / §6.6 临时覆盖 / §7.6 .gitignore / P1a bindings 索引)。
|
|
3
|
+
*
|
|
4
|
+
* 顺序不变式只住在这里:dropOverrideOnBind 必须在 writeBinding **之前**判前态
|
|
5
|
+
* (「绑定前是否未绑定」靠的就是当时的 binding),binding 落盘后才按新集收敛盘面。
|
|
6
|
+
* 收口前 bind() 与 `session/created` 自动绑定各写一遍,并已漂移:自动绑定漏发
|
|
7
|
+
* `/` 菜单失效事件、索引写失败被静默吞掉。
|
|
8
|
+
*/
|
|
9
|
+
import fs from 'node:fs';
|
|
10
|
+
import { writeBinding } from './binding.js';
|
|
11
|
+
import { converge } from './effective.js';
|
|
12
|
+
import { ensureGitignoreLine } from './gitignore.js';
|
|
13
|
+
import { dropOverrideOnBind } from './pending.js';
|
|
14
|
+
|
|
15
|
+
/**
|
|
16
|
+
* @param {object} opts
|
|
17
|
+
* @param {boolean} [opts.gitignore=true] .gitignore 署名行开关(host config.gitignoreLine)
|
|
18
|
+
* @param {(projectRoot: string, setSlug: string) => Promise<void>} [opts.index] bindings 索引登记
|
|
19
|
+
* @param {() => void} [opts.onCommitted] 生效清单落盘后的失效事件(/ 菜单缓存)
|
|
20
|
+
* @returns {Promise<{ applied: object, warnings: string[], plan: object, projectRoot: string }>}
|
|
21
|
+
*/
|
|
22
|
+
export async function bindProject(roots, projectRoot, setSlug, {
|
|
23
|
+
gitignore = true, index = null, onCommitted = null, fs: fsImpl = fs,
|
|
24
|
+
} = {}) {
|
|
25
|
+
dropOverrideOnBind(projectRoot, { fs: fsImpl });
|
|
26
|
+
writeBinding(projectRoot, setSlug, { fs: fsImpl });
|
|
27
|
+
const { plan, applied, warnings } = await converge(roots, projectRoot, setSlug, { fs: fsImpl });
|
|
28
|
+
ensureGitignoreLine(projectRoot, { enabled: gitignore }, { fs: fsImpl });
|
|
29
|
+
if (index) await index(projectRoot, setSlug);
|
|
30
|
+
if (onCommitted) onCommitted();
|
|
31
|
+
return { applied, warnings, plan, projectRoot };
|
|
32
|
+
}
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 常驻技能 = 从库链入全局生效区的那一小撮条目(§4.2/§5.3)——与项目生效同一链接机制,两处复用。
|
|
3
|
+
* 全局生效区既有内容他人所有:同名不抢占、退常驻只精确回收自建链接(links 台账)。
|
|
4
|
+
*/
|
|
5
|
+
import fs from 'node:fs';
|
|
6
|
+
import path from 'node:path';
|
|
7
|
+
import { loadResident, saveResident } from './sets.js';
|
|
8
|
+
import { makeEntry, removeEntry, entryKind } from './linkx.js';
|
|
9
|
+
import { diffPlan } from './plan.js';
|
|
10
|
+
|
|
11
|
+
/**
|
|
12
|
+
* M4(终审 2026-10-26):卸载常驻技能时从常驻名单剔除该名(调用方随后 syncResident 回收链接)。
|
|
13
|
+
* 否则名单幽灵名在 P3 弹窗语料里以灰行显示「已在所有项目生效」而实无库体无链接,文案失真。
|
|
14
|
+
* 命中返回 true;名单外返回 false(幂等)。
|
|
15
|
+
*/
|
|
16
|
+
export function dropResidentName(roots, name) {
|
|
17
|
+
const doc = loadResident(roots);
|
|
18
|
+
if (!doc.skills.includes(name)) return false;
|
|
19
|
+
saveResident(roots, doc.skills.filter((s) => s !== name), { links: doc.links });
|
|
20
|
+
return true;
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
/** 按 resident.json desired 状态同步全部 globalResidentDirs;返回 { linked, ghosts, warnings }。
|
|
24
|
+
* 幽灵名自动收敛(用户报告 2026-10-26:名单内技能体被外部删除 → 弹窗「缺失」幽灵 + 每次启动反复告警):
|
|
25
|
+
* 库里没有本体的名字 → 回收残留自建链并从名单剔除;回收失败则保留名单下次启动重试。 */
|
|
26
|
+
export async function syncResident(roots, { fs: fsImpl = fs } = {}) {
|
|
27
|
+
const doc = loadResident(roots);
|
|
28
|
+
const names = doc.skills;
|
|
29
|
+
const links = doc.links ?? {};
|
|
30
|
+
const warnings = [];
|
|
31
|
+
const ghosts = [];
|
|
32
|
+
for (const dir of roots.globalResidentDirs) {
|
|
33
|
+
const dirLinks = links[dir] ?? {};
|
|
34
|
+
const { add, remove, keep, warnMissing, warnForeign } = diffPlan({
|
|
35
|
+
names,
|
|
36
|
+
ledger: dirLinks,
|
|
37
|
+
resolve: (name) => {
|
|
38
|
+
const target = path.join(roots.libraryRoot, name);
|
|
39
|
+
let ok = false;
|
|
40
|
+
try { ok = fsImpl.statSync(path.join(target, 'SKILL.md')).isFile(); } catch {}
|
|
41
|
+
return ok ? { target } : null;
|
|
42
|
+
},
|
|
43
|
+
probe: (name) => {
|
|
44
|
+
const kind = entryKind(path.join(dir, name), { fs: fsImpl });
|
|
45
|
+
return { onDisk: kind !== 'missing', kind };
|
|
46
|
+
},
|
|
47
|
+
});
|
|
48
|
+
for (const name of warnMissing) { // 幽灵名:回收残留自建链并从名单剔除;回收失败则保留名单下次启动重试
|
|
49
|
+
if (dirLinks[name]) {
|
|
50
|
+
try { removeEntry(path.join(dir, name), dirLinks[name].kind, { fs: fsImpl }); }
|
|
51
|
+
catch (e) { warnings.push(`${name}: 幽灵残链回收失败(名单保留,下次启动重试): ${e?.message ?? e}`); continue; }
|
|
52
|
+
delete dirLinks[name];
|
|
53
|
+
}
|
|
54
|
+
if (!ghosts.includes(name)) ghosts.push(name);
|
|
55
|
+
warnings.push(`${name}: 库里没有技能体,已从常驻名单自动剔除`);
|
|
56
|
+
}
|
|
57
|
+
for (const w of warnForeign) warnings.push(`${w.name}: 全局生效区已有同名条目(他人所有),未抢占,常驻对该区未生效`);
|
|
58
|
+
// keep 也要重跑 makeEntry:「先摘再建」是修复语义(copied 条目每次机会重试 junction)
|
|
59
|
+
for (const name of [...keep, ...add.map((a) => a.name)]) {
|
|
60
|
+
const made = makeEntry(path.join(roots.libraryRoot, name), path.join(dir, name), { fs: fsImpl });
|
|
61
|
+
dirLinks[name] = { kind: made.kind, ...(made.copied ? { copied: true } : {}) };
|
|
62
|
+
if (made.copied) warnings.push(`${name}: 链接不可用,已复制(升级不自动传导)`);
|
|
63
|
+
}
|
|
64
|
+
for (const item of remove) {
|
|
65
|
+
removeEntry(path.join(dir, item.name), item.kind, { fs: fsImpl });
|
|
66
|
+
delete dirLinks[item.name];
|
|
67
|
+
}
|
|
68
|
+
links[dir] = dirLinks;
|
|
69
|
+
}
|
|
70
|
+
const kept = doc.skills.filter((s) => !ghosts.includes(s));
|
|
71
|
+
saveResident(roots, kept, { links });
|
|
72
|
+
return { linked: kept, ghosts, warnings };
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
/**
|
|
76
|
+
* P3 常驻区搬迁(设计 §6.4/§6.6):回收「links 台账里有记录、但目录已不在 globalResidentDirs」
|
|
77
|
+
* 的旧区自建链接(默认即 ~/.dsh/skills 遗留链),他人条目(台账无记录)一律不动。幂等。
|
|
78
|
+
*/
|
|
79
|
+
export async function pruneLegacyResidentLinks(roots, { fs: fsImpl = fs } = {}) {
|
|
80
|
+
const doc = loadResident(roots);
|
|
81
|
+
const links = doc.links ?? {};
|
|
82
|
+
const keep = new Set(roots.globalResidentDirs);
|
|
83
|
+
const pruned = [];
|
|
84
|
+
const warnings = [];
|
|
85
|
+
for (const dir of Object.keys(links)) {
|
|
86
|
+
if (keep.has(dir)) continue;
|
|
87
|
+
const failed = {};
|
|
88
|
+
for (const [name, rec] of Object.entries(links[dir] ?? {})) {
|
|
89
|
+
try { removeEntry(path.join(dir, name), rec?.kind, { fs: fsImpl }); }
|
|
90
|
+
catch (e) { warnings.push(`${dir}/${name}: ${e?.message ?? e}`); failed[name] = rec; continue; } // N1(终审 2026-10-26):失败项保留台账,下次启动重试(防旧链永驻被扫描区)
|
|
91
|
+
pruned.push({ dir, name });
|
|
92
|
+
}
|
|
93
|
+
if (Object.keys(failed).length) links[dir] = failed;
|
|
94
|
+
else delete links[dir];
|
|
95
|
+
}
|
|
96
|
+
saveResident(roots, doc.skills, { links });
|
|
97
|
+
return { pruned, warnings };
|
|
98
|
+
}
|