dsh-plugin-tool-management 0.17.0 → 0.18.0

package/lib/memories/archive.js

@@ -64,6 +64,9 @@ export function normalizeArchive(raw) {
         out.skills = normalizeStringList(obj.skills);
     if (obj.subagents != null)
         out.subagents = normalizeStringList(obj.subagents);
+    // 快捷提示词：`!= null` 才算定义（空表 = 定义了但全不勾 = 进入后全部停用，必须留住）。
+    if (obj.quickPrompts != null)
+        out.quickPrompts = normalizeStringList(obj.quickPrompts);
     if (obj.memories != null)
         out.memories = normalizeStringList(obj.memories);
     // 工具表方案是**标量**不是集合：空串 / 非字符串一律视为未绑定（段不存在）。
@@ -208,7 +211,12 @@ mcpNotes = [],
  */
 subagentStates = null, 
 /** 进场景前的模型工具表关停名单（null = 这次不进快照，退出也就不动工具表）。 */
-toolTableHidden = null) {
+toolTableHidden = null, 
+/**
+ * 进场景前**每一条**快捷提示词的开关（null = 档案没定义 quickPrompts 段 → 这一域不碰，
+ * 也就不进快照，退出同样一个字不动）。
+ */
+quickPromptStates = null) {
     return {
         mcp: Object.fromEntries(Object.entries(mcpRaw).map(([k, v]) => [k, v.slice()])),
         skills: { ...skills },
@@ -219,6 +227,7 @@ toolTableHidden = null) {
         ...(subagentStates ? { subagentsAll: { ...subagentStates } } : {}),
         ...(mcpNotes.length ? { mcpNotes: mcpNotes.map((x) => ({ id: x.id, note: x.note })) } : {}),
         ...(toolTableHidden ? { toolTableHidden: toolTableHidden.slice() } : {}),
+        ...(quickPromptStates ? { quickPromptsAll: { ...quickPromptStates } } : {}),
     };
 }
 // ── 记忆勾选（v3）──────────────────────────────────────────────────────────

package/lib/memories/discovery.js

@@ -0,0 +1,261 @@
+// 规则/记忆的**发现**：扫一个来源目录读成条目、把 frontmatter 投成规则、按老布局搬家。
+//
+// 声明从 memories/snapshot.ts 按行号区间搬来，正文一字未改（唯一的容差是
+// `--export-top-level` 加的 `export ` 前缀，moved-verify 逐字对拍）。
+//
+// 为什么与快照分两层：发现是「读外面进来的东西」（官方技能目录、AGENTS.md、旧布局），
+// 快照是「记下当前场景长什么样并写回索引」。两者各自演化的方向不同 —— 前者跟着**来源形状**
+// 变，后者跟着**索引字段**变。
+import { statSync } from 'node:fs';
+import { cp, lstat, mkdir, readdir, realpath, rename, rm } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { resolveDshHome, unquote } from '../skills/core.js';
+import { MAX_SOURCE_DEPTH, MAX_DIRECTORIES, MAX_ENTRIES, MAX_DESCRIPTION_LENGTH, DEFAULT_ORDER, GLOBAL_SCENE, LEGACY_BUNDLE_DOC, bundleDocName, SEGMENT_RULE_HINT, isValidGroupSegment } from './constants.js';
+import { pathExists } from './index-io.js';
+export const identity = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
+export async function discover(memoriesRoot) {
+    const entries = new Map();
+    const shadowed = [];
+    const groups = new Set();
+    const scenes = [];
+    const warnings = [];
+    const rootPath = resolve(memoriesRoot);
+    try {
+        const st = await lstat(rootPath);
+        if (!st.isDirectory() || st.isSymbolicLink())
+            return { entries, shadowed, groups, scenes, warnings, truncated: false };
+    }
+    catch {
+        return { entries, shadowed, groups, scenes, warnings, truncated: false };
+    }
+    const queue = [
+        { path: rootPath, group: '', depth: 0, ancestors: new Set() },
+    ];
+    let directories = 0;
+    let itemCount = 0;
+    let truncated = false;
+    const addEntry = (entry) => {
+        const existing = entries.get(entry.id);
+        if (!existing) {
+            entries.set(entry.id, entry);
+            return;
+        }
+        if (entry.kind === 'bundle' && existing.kind === 'flat') {
+            shadowed.push({ ...existing, shadowed: true });
+            entries.set(entry.id, entry);
+            return;
+        }
+        if (entry.kind === 'flat' && existing.kind === 'bundle') {
+            shadowed.push({ ...entry, shadowed: true });
+        }
+    };
+    for (let cursor = 0; cursor < queue.length; cursor++) {
+        if (directories >= MAX_DIRECTORIES || itemCount >= MAX_ENTRIES) {
+            truncated = true;
+            break;
+        }
+        const current = queue[cursor];
+        let realDirectory;
+        let dirents = [];
+        try {
+            realDirectory = await realpath(current.path);
+            if (current.ancestors.has(identity(realDirectory)))
+                continue;
+            const dir = await readdir(current.path, { withFileTypes: true });
+            directories++;
+            for (const item of dir) {
+                if (itemCount >= MAX_ENTRIES) {
+                    truncated = true;
+                    break;
+                }
+                itemCount++;
+                dirents.push(item);
+            }
+        }
+        catch {
+            continue; // 失效链接或不可读目录不阻断其他来源
+        }
+        // bundle 检查：当前目录含 `<目录名>.md`（或旧版 `SKILL.md`）→ 它是规则叶子，父路径为场景。
+        //
+        // **根下的一级目录恒为场景**（`parentGroup === ''` 时不做 bundle 判断）——与
+        // `probeSceneFilesSync`（注入段）同口径。场景 `1` 里一条叫 `1` 的记忆（`memories/1/1.md`）
+        // 与「根层的 bundle `1`」在磁盘上同形，认成后者会把整个场景目录吃成叶子：同场景其余
+        // 记忆全从列表消失、多出一条「未归属场景」的同名记忆，新建记忆还会被误报「同名 bundle
+        // 遮蔽」（2026-09-16 用户实测）。根层因此没有 bundle，只有 legacy 裸 .md（见 rulesCheck 的 noScene）。
+        if (current.group !== '') {
+            const sepIdx = current.group.lastIndexOf('/');
+            const parentGroup = sepIdx >= 0 ? current.group.slice(0, sepIdx) : '';
+            const name = sepIdx >= 0 ? current.group.slice(sepIdx + 1) : current.group;
+            let docPath = '';
+            if (parentGroup !== '') {
+                for (const candidate of [bundleDocName(name), LEGACY_BUNDLE_DOC]) {
+                    const p = join(current.path, candidate);
+                    try {
+                        const st = await lstat(p);
+                        if (st.isFile() && !st.isSymbolicLink()) {
+                            docPath = p;
+                            break;
+                        }
+                    }
+                    catch { /* 该候选名不存在 → 试下一个 */ }
+                }
+            }
+            if (docPath !== '') {
+                const id = parentGroup ? `${parentGroup}/${name}` : name;
+                addEntry({ id, group: parentGroup, name, kind: 'bundle', docPath, entryPath: current.path });
+                continue;
+            }
+        }
+        if (current.group !== '') {
+            groups.add(current.group);
+            // 一级目录 = 场景名（多段场景名用 '/' 连接，见 isValidGroupPath）。
+            if (current.depth === 1)
+                scenes.push(current.group);
+        }
+        dirents.sort((a, b) => a.name.localeCompare(b.name));
+        const ancestors = new Set(current.ancestors).add(identity(realDirectory));
+        for (const item of dirents) {
+            if (item.name.startsWith('.'))
+                continue; // 隐藏目录/文件跳过
+            const path = join(current.path, item.name);
+            try {
+                const st = await lstat(path);
+                // 符号链接一律不跟随：注入路径（`probeSceneFilesSync`）本来就不跟随，两端必须同口径 ——
+                // 否则列表里会出现**永远注入不进去**的记忆（用户打开开关却什么也没发生）。顺带也关掉了
+                // 「链接指向根外、写操作顺着链接穿透出去」这条路（写入侧另有 realpath 断言兜底）。
+                if (st.isSymbolicLink())
+                    continue;
+                if (st.isDirectory()) {
+                    if (!isValidGroupSegment(item.name)) {
+                        warnings.push(`跳过非法目录名（${SEGMENT_RULE_HINT}）：${current.group ? current.group + '/' : ''}${item.name}`);
+                        continue;
+                    }
+                    if (current.depth >= MAX_SOURCE_DEPTH || queue.length >= MAX_DIRECTORIES) {
+                        truncated = true;
+                        continue;
+                    }
+                    queue.push({
+                        path,
+                        group: current.group ? `${current.group}/${item.name}` : item.name,
+                        depth: current.depth + 1,
+                        ancestors,
+                    });
+                    continue;
+                }
+                if (!st.isFile())
+                    continue;
+                if (!item.name.toLowerCase().endsWith('.md'))
+                    continue; // 只认 .md
+                const name = item.name.slice(0, -3);
+                const id = current.group ? `${current.group}/${name}` : name;
+                addEntry({ id, group: current.group, name, kind: 'flat', docPath: path, entryPath: path });
+            }
+            catch {
+                /* 来源在扫描期间失效时跳过 */
+            }
+        }
+    }
+    return { entries, shadowed, groups, scenes, warnings, truncated };
+}
+export function deriveDescription(body) {
+    const text = String(body ?? '').trim();
+    if (!text)
+        return '';
+    const heading = /^#\s+(.+)$/m.exec(text);
+    const raw = heading && heading[1].trim() ? heading[1].trim() : text.split(/\r?\n/, 1)[0].trim();
+    return raw.slice(0, MAX_DESCRIPTION_LENGTH);
+}
+export function deriveFromDoc(entry, doc) {
+    const declaredName = doc.map.name != null && String(doc.map.name).trim() !== '' ? unquote(String(doc.map.name)).trim() : '';
+    const name = declaredName || entry.name;
+    let description = doc.map.description != null ? unquote(String(doc.map.description)).trim() : '';
+    let descriptionDerived = false;
+    if (description === '') {
+        description = deriveDescription(doc.body);
+        descriptionDerived = true;
+    }
+    const globs = doc.map.globs != null && String(doc.map.globs).trim() !== '' ? String(doc.map.globs).trim() : undefined;
+    let whenToUse;
+    if (doc.map.whenToUse != null && String(doc.map.whenToUse).trim() !== '') {
+        whenToUse = String(doc.map.whenToUse).trim();
+    }
+    else if (globs) {
+        whenToUse = `适用路径：${globs}`;
+    }
+    const metadata = doc.map.metadata !== undefined ? doc.map.metadata : undefined;
+    return { name, description, descriptionDerived, whenToUse, globs, metadata };
+}
+export function projectRule(entry, derived, idxEntry) {
+    // 体积按**正文文件**算（bundle 的附件不计：附件不进注入正文）。一次 stat 一条记忆，
+    // 结果随快照的 1s TTL 缓存一起复用；读不到就不带这个字段，别把"不知道"报成 0 B。
+    let size;
+    try {
+        size = statSync(entry.docPath).size;
+    }
+    catch {
+        size = undefined;
+    }
+    const rule = {
+        id: entry.id,
+        group: entry.group,
+        name: derived.name,
+        form: entry.kind,
+        path: entry.docPath,
+        ...(size !== undefined ? { bytes: size } : {}),
+        description: derived.description,
+        ...(derived.descriptionDerived ? { descriptionDerived: true } : {}),
+        ...(derived.whenToUse !== undefined ? { whenToUse: derived.whenToUse } : {}),
+        ...(derived.globs !== undefined ? { globs: derived.globs } : {}),
+        ...(derived.metadata !== undefined ? { metadata: derived.metadata } : {}),
+        enabled: idxEntry?.enabled ?? true,
+        order: idxEntry?.order ?? DEFAULT_ORDER,
+        tags: Array.isArray(idxEntry?.tags) ? idxEntry.tags : [],
+        pinned: idxEntry?.pinned === true,
+        note: typeof idxEntry?.note === 'string' ? idxEntry.note : '',
+        ...(typeof idxEntry?.updatedAt === 'string' ? { updatedAt: idxEntry.updatedAt } : {}),
+    };
+    return rule;
+}
+export async function relocateLegacyLayout(memoriesRoot) {
+    const home = resolveDshHome();
+    const legacyRoots = [join(home, 'scene-memory'), join(home, 'rules')];
+    for (const legacyRoot of legacyRoots) {
+        if (!(await pathExists(legacyRoot)))
+            continue;
+        if (identity(resolve(legacyRoot)) === identity(resolve(memoriesRoot)))
+            continue; // 自定义 roots 落在旧路径 → 不自我搬移
+        let items;
+        try {
+            items = await readdir(legacyRoot, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const item of items) {
+            if (item.name.startsWith('.'))
+                continue;
+            const src = join(legacyRoot, item.name);
+            // 根层 .md = 旧的「全局」桶 → 搬进 `global/`，文件名保留（否则多套一层目录）。
+            // 其余条目（场景目录）整体搬进 memories/，目录名保留。
+            const isRootMd = item.isFile() && item.name.toLowerCase().endsWith('.md');
+            const destDir = isRootMd ? join(memoriesRoot, GLOBAL_SCENE) : memoriesRoot;
+            const dest = join(destDir, item.name);
+            try {
+                if (await pathExists(dest))
+                    continue;
+                await mkdir(destDir, { recursive: true });
+                try {
+                    await rename(src, dest);
+                }
+                catch {
+                    // 跨设备/被占用 → 复制后删源；复制失败则保留源文件（宁可重复，不可丢失）。
+                    await cp(src, dest, { recursive: true });
+                    await rm(src, { recursive: true, force: true });
+                }
+            }
+            catch {
+                /* 单项失败不阻断其余项（如文件被外部程序锁住，下次启动再试） */
+            }
+        }
+    }
+}

package/lib/memories/export-plan.js

@@ -0,0 +1,42 @@
+// 记忆导出的落盘映射：把「导出哪几条记忆」算成 zip 里的条目与缺失清单。
+//
+// 从 memories/service.ts 整段搬来，一行未改。它是纯函数（不碰磁盘）——flat / bundle 两种
+// 形态与「场景名本身可含 /」的口径都写在它自己的注释里，那条口径两边必须一致。
+import { dirname } from 'node:path';
+/**
+ * 记忆导出的落盘映射（`bundle-export` 的 `kind: 'memories'` 用，见 design-plan D14）。
+ *
+ * 记忆有两种形态（见文件头）：flat = `<场景>/<name>.md`，bundle = `<场景>/<name>/<name>.md`；
+ * 而且**场景名本身可含 `/`**（多段场景名，见 `isValidGroupPath`）。所以「按 id 的最后一个
+ * `/` 切出场景与名字、再拼 `.md`」是错的：bundle 会被读成 `<场景>/<name>.md` → 读不到 →
+ * 该项目静默丢失（只在 `missing` 里留个名，界面按「导出成功」显示）。
+ *
+ * 这里一律按索引里那条规则自己的 `path` 与 `form` 决定；bundle 只交出目录，由调用方
+ * 把目录内的文件全部打包（与技能分支同口径）。索引里没有、或已被同名 bundle 遮蔽的 id
+ * 进 `missing`——遮蔽的 flat 不会被加载，导出去只会让人以为它能用。
+ *
+ * 纯函数（不碰磁盘），可直接断言。
+ */
+export function planMemoryExport(names, rules) {
+    const list = Array.isArray(names) ? names.map((n) => String(n).trim()).filter(Boolean) : [];
+    const byId = new Map();
+    for (const row of (Array.isArray(rules) ? rules : [])) {
+        const id = row && typeof row.id === 'string' ? row.id : '';
+        if (id !== '')
+            byId.set(id, row);
+    }
+    const entries = [];
+    const missing = [];
+    for (const id of list) {
+        const row = byId.get(id);
+        const abs = row && typeof row.path === 'string' ? row.path : '';
+        if (!row || abs === '' || row.shadowed === true) {
+            missing.push(id);
+            continue;
+        }
+        entries.push(row.form === 'bundle'
+            ? { id, zip: id, abs: dirname(abs), kind: 'dir' }
+            : { id, zip: `${id}.md`, abs, kind: 'file' });
+    }
+    return { entries, missing };
+}

package/lib/memories/memories-types.js

@@ -0,0 +1 @@
+export {};

package/lib/memories/service.js

@@ -2,6 +2,9 @@
 import { buildMemoryOps } from '../ops/memory.js';
 import { buildTrashOps } from '../ops/trash.js';
 import { buildSceneRecordOps } from '../ops/scene-records.js';
+// 类型面与导出计划拆出去后，memories/service.js 的公开面照旧（snapshot.ts、projection.ts、
+// index-io.ts、ops/* 与 index.ts 都按这个路径引）。
+export { planMemoryExport } from './export-plan.js';
 // dsh-plugin-tool-management —— 规则/记忆（Rules v0.3，见 CHANGE-REQUEST-01）服务层。
 //
 // 记忆 = $DSH_HOME/tool-management/memories/<场景>/<name>.md（flat）或 <场景>/<name>/<name>.md（bundle）。
@@ -38,7 +41,7 @@ import { createHash } from 'node:crypto';
 import { readFileSync, statSync } from 'node:fs';
 import { copyFile, lstat, mkdir, readFile, readdir, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { join, resolve } from 'node:path';
 import { isInsideRootResolved } from '../paths.js';
 import { parseSkillDoc, resolveDshHome } from '../skills/core.js';
 import { newTrashId } from '../hub.js';
@@ -74,43 +77,6 @@ export const SCENES_DIR = 'scenes';
 export const MEMORIES_DIR = 'memories';
 /** 提示词预设库目录名（hub 根下；域 = 提示词，工具 `prompt_manager_*`）。 */
 export const PRESETS_DIR = 'prompts';
-/**
- * 记忆导出的落盘映射（`bundle-export` 的 `kind: 'memories'` 用，见 design-plan D14）。
- *
- * 记忆有两种形态（见文件头）：flat = `<场景>/<name>.md`，bundle = `<场景>/<name>/<name>.md`；
- * 而且**场景名本身可含 `/`**（多段场景名，见 `isValidGroupPath`）。所以「按 id 的最后一个
- * `/` 切出场景与名字、再拼 `.md`」是错的：bundle 会被读成 `<场景>/<name>.md` → 读不到 →
- * 该项目静默丢失（只在 `missing` 里留个名，界面按「导出成功」显示）。
- *
- * 这里一律按索引里那条规则自己的 `path` 与 `form` 决定；bundle 只交出目录，由调用方
- * 把目录内的文件全部打包（与技能分支同口径）。索引里没有、或已被同名 bundle 遮蔽的 id
- * 进 `missing`——遮蔽的 flat 不会被加载，导出去只会让人以为它能用。
- *
- * 纯函数（不碰磁盘），可直接断言。
- */
-export function planMemoryExport(names, rules) {
-    const list = Array.isArray(names) ? names.map((n) => String(n).trim()).filter(Boolean) : [];
-    const byId = new Map();
-    for (const row of (Array.isArray(rules) ? rules : [])) {
-        const id = row && typeof row.id === 'string' ? row.id : '';
-        if (id !== '')
-            byId.set(id, row);
-    }
-    const entries = [];
-    const missing = [];
-    for (const id of list) {
-        const row = byId.get(id);
-        const abs = row && typeof row.path === 'string' ? row.path : '';
-        if (!row || abs === '' || row.shadowed === true) {
-            missing.push(id);
-            continue;
-        }
-        entries.push(row.form === 'bundle'
-            ? { id, zip: id, abs: dirname(abs), kind: 'dir' }
-            : { id, zip: `${id}.md`, abs, kind: 'file' });
-    }
-    return { entries, missing };
-}
 export function createMemoriesService(ctx, deps) {
     // 仅测试注入绝对路径；生产按 $DSH_HOME 解析（与核心技能目录同源）。
     // v0.4：全部落到 $DSH_HOME/tool-management/ 一个目录内（memories/ + scenes/ + 侧车），