dsh-plugin-tool-management 0.1.3 → 0.2.0

package/lib/index.js

@@ -14,6 +14,7 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 import { createRequire } from 'node:module';
 import { createSkillsService } from './skills/service.js';
 import { createAgentsMdService } from './agents-md/service.js';
+import { createRulesService } from './rules/service.js';
 import { detectFormat, extractText, parseGenericText, parseJsonlTranscript, parseMarkdownTranscript } from './imports/parsers.js';
 import { homedir } from 'node:os';
 import { spawn } from 'node:child_process';
@@ -96,6 +97,11 @@ export default {
             'history-archive', 'history-unarchive', 'history-delete', 'history-retention-set',
             'history-unarchive-batch', 'history-delete-batch', 'history-import', 'history-export',
             'history-archive-batch',
+            // rules 写操作（v0.3：create/update/remove/restore 改记忆文件；toggle/set-index/
+            // set-active 改侧车索引；create-scene/remove-scene 建删场景目录。
+            // set-active = 插件内"启用场景"开关，全局持久化）
+            'rules-create', 'rules-update', 'rules-remove', 'rules-restore', 'rules-toggle', 'rules-set-index', 'rules-set-active',
+            'rules-create-scene', 'rules-remove-scene',
         ]);
         const wait = (ms) => ctx.timeout(ms);
         const message = (e) => String((e && e.message) || e);
@@ -139,6 +145,25 @@ export default {
                 return p.home + sep + 'AGENTS.md';
             },
         });
+        // ---------- rules（规则/记忆，v0.3）----------
+        // 规则真源 $DSH_HOME/rules/<场景>/<name>.md（仅用户级，D1）。**场景 = 一级目录**；
+        // 单投影 = 活动场景记忆 → per-agent systemPrompt 段（自动在场，模型无需调用任何工具）。
+        // 原"始终层写 ~/.dsh/AGENTS.md"已下线（变更单 01 §4/§10）：公共基线由 _shared/ 承担。
+        // rulesRoot / rulesStateDir 仅测试注入，生产留空由服务按 DSH_HOME 解析。
+        const rulesService = createRulesService(ctx, {
+            rulesRoot: String(config?.rulesRoot || ''),
+            stateDir: String(config?.rulesStateDir || ''),
+            // 场景记忆段预算（字节），默认 65536；仅用于测试与特殊部署调优。
+            ...(Number.isFinite(Number(config?.rulesMaxBytes))
+                ? { maxBytes: Number(config.rulesMaxBytes) }
+                : {}),
+        });
+        try {
+            ctx.effect(() => rulesService.registerProviders(), 'dsh-plugin-tool-management: rules providers');
+        }
+        catch (e) {
+            console.error('[dsh-plugin-tool-management] rules provider setup failed:', message(e));
+        }
         // ---------- history（归档会话管理，折叠自 dsh-archive-manager）----------
         // cordis.patch.yml 禁用官方 workspace 与 session-projection-cache，插入本插件
         // 的归档感知子类（lib/history/workspace.js + lib/history/projcache.js）。子类
@@ -899,7 +924,7 @@ export default {
                 return { ok: true, notes: map };
             });
         }
-        const SETTINGS_DEFAULTS = { pollIntervalMs: 5000, toolDescriptionMaxLength: 0 };
+        const SETTINGS_DEFAULTS = { pollIntervalMs: 5000, toolDescriptionMaxLength: 0, requireConfirmForModelRuleWrite: true };
         let pluginSettingsCache = null;
         function clampInt(value, min, max, fallback) {
             // Number(null) is 0 — treat missing/empty input as "use the default".
@@ -921,6 +946,10 @@ export default {
                     pollIntervalMs: clampInt(raw && raw.pollIntervalMs, 2000, 60000, SETTINGS_DEFAULTS.pollIntervalMs),
                     // 0 = keep descriptions in full (the UI default); > 0 truncates.
                     toolDescriptionMaxLength: clampInt(raw && raw.toolDescriptionMaxLength, 0, 2000, SETTINGS_DEFAULTS.toolDescriptionMaxLength),
+                    // 模型写规则需确认（D2）：程序化强制，只读设置供 tools/pre-execute 判定。
+                    requireConfirmForModelRuleWrite: (raw && typeof raw.requireConfirmForModelRuleWrite === 'boolean')
+                        ? raw.requireConfirmForModelRuleWrite
+                        : SETTINGS_DEFAULTS.requireConfirmForModelRuleWrite,
                 },
             };
             return pluginSettingsCache.value;
@@ -932,6 +961,9 @@ export default {
             const next = {
                 pollIntervalMs: clampInt(args.pollIntervalMs, 2000, 60000, current.pollIntervalMs),
                 toolDescriptionMaxLength: clampInt(args.toolDescriptionMaxLength, 0, 2000, current.toolDescriptionMaxLength),
+                requireConfirmForModelRuleWrite: (args && typeof args.requireConfirmForModelRuleWrite === 'boolean')
+                    ? args.requireConfirmForModelRuleWrite
+                    : current.requireConfirmForModelRuleWrite,
             };
             const p = await ensurePaths();
             return withWriteLock(async () => {
@@ -1782,6 +1814,12 @@ export default {
             // skill-delete / skill-trash-restore / skill-trash-delete
             // 成功返回 {ok:true, data}；core 业务失败原样透传 {ok:false, error, code?, params?}。
             ...skillsService.ops,
+            // rules ops（由 ./rules/service.js 提供）：rules-list / rules-read / rules-budget /
+            // rules-diagnose / rules-create / rules-update / rules-remove / rules-restore /
+            // rules-trash-list / rules-trash-remove / rules-toggle / rules-set-index /
+            // rules-set-active / rules-create-scene / rules-remove-scene。
+            // 成功返回扁平 {ok:true, ...}（不套 data），失败 {ok:false, error, code?}。
+            ...rulesService.ops,
             // AGENTS.md 预设库 ops（由 ./agents-md/service.js 提供）：agentsmd-list /
             // agentsmd-read / agentsmd-create / agentsmd-update / agentsmd-remove /
             // agentsmd-apply / agentsmd-get-current
@@ -2349,12 +2387,73 @@ export default {
                 return 'OK: preset ' + args.id + ' applied to ~/.dsh/AGENTS.md (next session; current session unchanged' + (r.backedUp ? '; previous backed up to __last-applied__' : '') + ')';
             },
         }));
+        // ---------- rules model tools（v0.3）----------
+        // 活动场景的记忆正文会自动进入系统提示词（无需调用工具读取）；这里的工具用于
+        // 查询/编辑规则本身。rule_manager_write 受 tools/pre-execute 审批门禁（D2）。
+        tools.register(defineTool({
+            name: 'rule_manager_list',
+            description: 'List rules/memories under ~/.dsh/scene-memory (id, scene, enabled, description).',
+            parameters: {
+                group: { type: 'string', description: 'Optional group/scene filter.' },
+            },
+            output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
+            async execute(args) {
+                const r = await rulesService.ops['rules-list'](args);
+                if (!r || r.ok === false)
+                    throw new Error((r && r.error) || '读取规则失败');
+                const lines = (r.rules || []).map((x) => ('- ' + x.id + ' [' + (x.group || '全局') + '] ' + (x.enabled ? '已启用' : '已停用') +
+                    (x.description ? ' — ' + x.description : '')));
+                const scenes = (r.scenes || []).map((s) => s.name + (s.active ? '(启用)' : '(未启用)')).join('、');
+                return '规则（' + (r.rules || []).length + '）：\n' + (lines.join('\n') || '(无规则)') +
+                    '\n场景：' + (scenes || '(无)') + (r.activeMode === 'all' ? '（默认全部启用）' : '（已收窄）');
+            },
+        }));
+        tools.register(defineTool({
+            name: 'rule_manager_read',
+            description: 'Read the full body of one rule/memory under ~/.dsh/scene-memory.',
+            parameters: {
+                id: { type: 'string', required: true, description: 'Rule id like <scene>/<name>.' },
+            },
+            output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
+            async execute(args) {
+                const r = await rulesService.ops['rules-read'](args);
+                if (!r || r.ok === false)
+                    throw new Error((r && r.error) || '读取规则失败');
+                return '# ' + r.rule.id + '\n\n' + (r.rule.body || '');
+            },
+        }));
+        tools.register(defineTool({
+            name: 'rule_manager_write',
+            description: 'Create a new rule/memory as ~/.dsh/scene-memory/<scene>/<name>.md. It becomes active automatically once its scene is enabled. Requires user confirmation (configurable).',
+            parameters: {
+                group: { type: 'string', required: true, description: 'Scene/folder name under ~/.dsh/scene-memory (any Unicode except path separators and < > : " | ? *).' },
+                name: { type: 'string', required: true, description: 'Memory name = the .md file name without the extension; any Unicode is fine (Chinese included), <=64 chars, no path separators or < > : " | ? *, must not start with a dot.' },
+                description: { type: 'string', required: true, description: 'One-sentence description (<=500 chars).' },
+                body: { type: 'string', required: true, description: 'Markdown body (<=256 KiB).' },
+            },
+            output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
+            async execute(args) {
+                const r = await rulesService.ops['rules-create'](args);
+                if (!r || r.ok === false)
+                    throw new Error((r && r.error) || '创建规则失败');
+                return 'OK: rule ' + r.rule.id + '（场景「' + (r.rule.group || '全局') + '」启用后自动生效）';
+            },
+        }));
         if (typeof ctx.on === 'function') {
             ;
             ctx.on('tools/pre-execute', (exec, next) => {
                 if (exec && exec.name === 'skill_manager_create') {
                     return Promise.resolve({ kind: 'ask', reason: 'Create a new skill under DSH_HOME/skills' });
                 }
+                if (exec && exec.name === 'rule_manager_write') {
+                    // D2：模型写规则默认需确认；设置关闭后直接放行。ask 无应答者时降级为拒绝（fail-closed），
+                    // 不在此处做任何兜底放行。
+                    return readPluginSettings()
+                        .then((s) => (s.requireConfirmForModelRuleWrite
+                        ? { kind: 'ask', reason: 'Write a rule under ~/.dsh/scene-memory' }
+                        : next()))
+                        .catch(() => ({ kind: 'ask', reason: 'Write a rule under ~/.dsh/scene-memory' }));
+                }
                 return next();
             });
         }
@@ -2573,6 +2672,23 @@ export default {
                         return { kind: 'success', text };
                     },
                 }), 'dsh-plugin-tool-management: /agents-md command');
+                ctx.effect(() => commands.register({
+                    name: 'scene-memory',
+                    description: '列出场景记忆及其场景启用状态',
+                    handler: async () => {
+                        const r = await rulesService.ops['rules-list']({});
+                        if (!r || r.ok === false)
+                            return { kind: 'error', text: (r && r.error) || '读取记忆失败' };
+                        const rules = r.rules || [];
+                        if (!rules.length)
+                            return { kind: 'success', text: '未发现任何记忆（~/.dsh/scene-memory 为空）。' };
+                        const scenes = r.scenes || [];
+                        const text = '场景记忆（' + rules.length + '）：\n' + rules.map((rule) => ('- ' + rule.name + ' [' + (rule.group || '全局') + '] · ' + (rule.enabled ? '已启用' : '已停用'))).join('\n') + '\n场景：' + (scenes.map((s) => s.name + (s.active ? '(启用)' : '(未启用)')).join('、') || '(无)') +
+                            (r.activeMode === 'all' ? '（默认全部启用）' : '（已收窄）') +
+                            '\n（启用场景的记忆正文自动进入系统提示词，无需任何工具调用）';
+                        return { kind: 'success', text };
+                    },
+                }), 'dsh-plugin-tool-management: /scene-memory command');
             }
         }
         catch (e) {

package/lib/rules/provider.js

@@ -0,0 +1,121 @@
+// dsh-plugin-tool-management —— 规则「自动在场层」投影（systemPrompt 段注册）。
+//
+// 变更单 01 的核心：把规则从"投影为 skill 目录条目（模型按需 load）"改为
+// **投影为 system prompt 段（自动在场）**。前者即使命中，模型也要自己决定看不看，
+// 正是用户抱怨的"每次都要解释"。
+//
+// 官方接口语义（@deepseek-ai/dsh-system-prompt）：
+//   - `section({ name, order, text })` 在**调用者的 scope** 注册；scoped 段遮蔽同名全局段。
+//   - `text` 可以是**每次装配时求值的 provider 函数** → 切换启用场景后**下一个请求即生效**，
+//     无需重开会话、无需重载插件。
+//   - `renderPrompt` 会**删除空段** → 无启用场景/空目录时返回 `''`，不产生空标题。
+//
+// 为什么注册两处（全局 + per-agent）：
+//   全局注册覆盖所有 agent（含子 agent）；per-agent 注册保证即使插件 ctx 自带 scope
+//   （全局段对某些 agent 不可见）也能命中 —— 两者同名，scoped 遮蔽全局，不会重复注入。
+//
+// 缓存契约（§5.2）：段文本是**会话级恒定**的（只由启用场景与文件内容决定），
+// 因此前缀逐字节稳定 → 前缀缓存可命中；禁止在段里放时间戳/计数/相对时间。
+const SECTION_NAME = 'tool-management:scene-memory';
+/**
+ * §5.1 硬约束 2：官方 `SECTION_ORDERS` 里 2901–4999 是空档（TOOL_REPORT 2900 →
+ * TOOLS_SDK 5000），取 **3000** —— 语义上是"工具能力说明之后、输出与 SDK 约定之前"，
+ * 且远离任何既有段。**不要**用官方已有数值（同号按名称排序，虽确定但难读，日后易撞）。
+ */
+const SECTION_ORDER = 3000;
+const GLOBAL_KEY = '@global';
+/** 取 scope 上的 systemPrompt 服务（Cordis 的 ctx.get 可能抛错，全部吞掉）。 */
+function systemPromptOf(scope) {
+    if (!scope)
+        return undefined;
+    try {
+        if (typeof scope.get === 'function')
+            return scope.get('systemPrompt');
+        return scope.systemPrompt;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 注册全局 + agent-scope 的场景记忆段。 */
+export function createRuleProviderRegistrar(ctx, facade) {
+    const registrations = new Map();
+    const install = (scope, key) => {
+        if (!scope || registrations.has(key))
+            return;
+        const systemPrompt = systemPromptOf(scope);
+        if (!systemPrompt || typeof systemPrompt.section !== 'function')
+            return;
+        try {
+            const dispose = systemPrompt.section({
+                name: SECTION_NAME,
+                order: SECTION_ORDER,
+                // 每次装配重读活动场景 → 切换启用状态后下一个请求即生效。
+                // ⚠️ 硬约束 1：必须**同步返回 string**（不能是 Promise）——异步读取会破坏 renderPrompt。
+                text: () => facade.renderActiveScenes(),
+            });
+            registrations.set(key, { scope, dispose: typeof dispose === 'function' ? dispose : () => { } });
+        }
+        catch (e) {
+            // 同层重名注册会抛错：降级为"该 scope 不注入"，不影响其余 scope。
+            console.error('[dsh-plugin-tool-management] scene-memory section registration failed:', String((e && e.message) || e));
+        }
+    };
+    const uninstall = (key) => {
+        const entry = registrations.get(key);
+        if (!entry)
+            return;
+        registrations.delete(key);
+        try {
+            entry.dispose();
+        }
+        catch { /* ignore */ }
+    };
+    // ① 全局：插件 ctx 的 scope（覆盖所有 agent）
+    install(ctx, GLOBAL_KEY);
+    // ② per-agent：与既有 install/uninstall 生命周期一致（agent/created、agent/disposed）
+    const on = ctx && ctx.on;
+    let stopCreated;
+    let stopDisposed;
+    if (typeof on === 'function') {
+        stopCreated = on('agent/created', (payload) => {
+            const agent = payload && payload.agent;
+            if (agent && agent.id != null)
+                install(agent.ctx, String(agent.id));
+        });
+        stopDisposed = on('agent/disposed', (payload) => {
+            const agent = payload && payload.agent;
+            if (agent && agent.id != null)
+                uninstall(String(agent.id));
+        });
+    }
+    // 已存在的 agent（插件热加载场景）：补注册。
+    try {
+        const agents = typeof ctx.get === 'function' ? ctx.get('agents') : undefined;
+        if (agents && typeof agents.list === 'function') {
+            for (const agent of agents.list()) {
+                if (agent && agent.id != null)
+                    install(agent.ctx, String(agent.id));
+            }
+        }
+    }
+    catch { /* agents 服务不可用 → 仅靠事件 */ }
+    return {
+        invalidate: () => {
+            for (const entry of registrations.values()) {
+                try {
+                    entry.scope?.emit?.('system-prompt/change');
+                }
+                catch { /* 宿主无该事件 → 忽略 */ }
+            }
+        },
+        dispose: () => {
+            if (typeof stopCreated === 'function')
+                stopCreated();
+            if (typeof stopDisposed === 'function')
+                stopDisposed();
+            for (const key of [...registrations.keys()])
+                uninstall(key);
+        },
+    };
+}