remnote-bridge 0.1.12 → 0.1.13

package/dist/cli/commands/edit-rem.js

@@ -1,17 +1,17 @@
 /**
  * edit-rem 命令
  *
- * 通过 str_replace 编辑 Rem 的 JSON 序列化。
- * 三道防线保证安全：缓存存在性、并发检测、精确匹配。
+ * 直接修改 Rem 的属性字段。
+ * 两道防线保证安全：缓存存在性、并发检测。
  * - 退出码：0 成功 / 1 业务错误 / 2 守护进程不可达
  */
 import { sendDaemonRequest } from '../daemon/send-request.js';
 import { jsonOutput, handleCommandError } from '../utils/output.js';
 export async function editRemCommand(remId, options) {
-    const { json, oldStr, newStr } = options;
+    const { json, changes } = options;
     let result;
     try {
-        result = await sendDaemonRequest('edit_rem', { remId, oldStr, newStr });
+        result = await sendDaemonRequest('edit_rem', { remId, changes });
     }
     catch (err) {
         handleCommandError(err, 'edit-rem', json);
@@ -32,7 +32,7 @@ export async function editRemCommand(remId, options) {
     else {
         if (editResult.ok) {
             if (editResult.changes.length === 0) {
-                console.log('无变更（old_str 和 new_str 产生相同结果）');
+                console.log('无变更（未发现可写入的变更字段）');
             }
             else {
                 console.log(`已更新字段: ${editResult.changes.join(', ')}`);

package/dist/cli/commands/read-rem.js

@@ -20,7 +20,9 @@ export async function readRemCommand(remId, options = {}) {
         payload.full = true;
     }
     else if (fields) {
-        payload.fields = fields.split(',').map(f => f.trim()).filter(Boolean);
+        payload.fields = Array.isArray(fields)
+            ? fields
+            : fields.split(',').map(f => f.trim()).filter(Boolean);
     }
     let result;
     try {

package/dist/cli/handlers/edit-handler.js

@@ -1,17 +1,12 @@
 /**
  * EditHandler — edit-rem 命令的编排器
  *
- * 在 daemon 层实现三道防线 + str_replace + 后处理校验。
+ * 在 daemon 层实现两道防线 + 字段白名单校验 + 直接转发 changes。
  * Plugin 只负责原子写入（write_rem_fields）。
  *
  * 防线 1：缓存存在性检查（必须先 read 再 edit）
  * 防线 2：乐观并发检测（当前 JSON 与缓存 JSON 比较）
- * 防线 3：str_replace 精确匹配（old_str 必须唯一匹配）
- *
- * Portal 专用路径：type === 'portal' 时，在简化 JSON（9 字段）上执行 str_replace，
- * 推导变更后调用专用写入逻辑。
  */
-import { PORTAL_FIELDS } from './read-handler.js';
 /** 只读字段集合 — 变更这些字段只产生警告，不执行写入 */
 const READ_ONLY_FIELDS = new Set([
     'id',
@@ -30,10 +25,22 @@ const READ_ONLY_FIELDS = new Set([
     'isPowerup', 'isPowerupEnum', 'isPowerupProperty',
     'isPowerupPropertyListItem', 'isPowerupSlot',
 ]);
-/** Portal 简化 JSON 中的只读字段 */
-const PORTAL_READONLY_FIELDS = new Set([
-    'id', 'type', 'portalType', 'children', 'createdAt', 'updatedAt',
+/** 可写字段白名单 — 21 个可写字段 */
+const WRITABLE_FIELDS = new Set([
+    'text', 'backText', 'type', 'isDocument', 'parent',
+    'fontSize', 'highlightColor',
+    'isTodo', 'todoStatus', 'isCode', 'isQuote', 'isListItem', 'isCardItem', 'isSlot', 'isProperty',
+    'enablePractice', 'practiceDirection',
+    'tags', 'sources', 'positionAmongstSiblings', 'portalDirectlyIncludedRem',
 ]);
+/** 枚举字段的合法值 */
+const ENUM_VALUES = {
+    type: new Set(['concept', 'descriptor', 'default']),
+    practiceDirection: new Set(['forward', 'backward', 'both', 'none']),
+    highlightColor: new Set(['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Purple', 'Gray', 'Brown', 'Pink', null]),
+    fontSize: new Set(['H1', 'H2', 'H3', null]),
+    todoStatus: new Set(['Finished', 'Unfinished', null]),
+};
 export class EditHandler {
     cache;
     forwardToPlugin;
@@ -42,145 +49,61 @@ export class EditHandler {
         this.forwardToPlugin = forwardToPlugin;
     }
     async handleEditRem(payload) {
-        const { remId, oldStr, newStr } = payload;
+        const { remId, changes } = payload;
+        if (!changes || typeof changes !== 'object' || Object.keys(changes).length === 0) {
+            return { ok: true, changes: [], warnings: [] };
+        }
         // ── 防线 1: 缓存存在性检查 ──
-        const cachedJson = this.cache.get('rem:' + remId);
-        if (!cachedJson) {
+        const cachedObj = this.cache.get('rem:' + remId);
+        if (!cachedObj) {
             throw new Error(`Rem ${remId} has not been read yet. Read it first before editing.`);
         }
         // ── 防线 2: 乐观并发检测 ──
         const currentRemObject = await this.forwardToPlugin('read_rem', { remId });
         const currentJson = JSON.stringify(currentRemObject, null, 2);
+        const cachedJson = JSON.stringify(cachedObj, null, 2);
         if (currentJson !== cachedJson) {
             // 不更新缓存 — 迫使 AI re-read
             throw new Error(`Rem ${remId} has been modified since last read. Please read it again before editing.`);
         }
-        // ── 检测 Portal 类型，分流到专用路径 ──
-        const cachedObj = JSON.parse(cachedJson);
-        if (cachedObj.type === 'portal') {
-            return this.handlePortalEdit(remId, cachedJson, cachedObj, oldStr, newStr);
-        }
-        // ── 普通 Rem 路径 ──
-        return this.handleNormalEdit(remId, cachedJson, cachedObj, oldStr, newStr);
-    }
-    /** Portal 专用编辑路径：在简化 JSON 上执行 str_replace */
-    async handlePortalEdit(remId, cachedJson, fullObj, oldStr, newStr) {
-        // 从完整对象提取简化 JSON
-        const simplified = {};
-        for (const field of PORTAL_FIELDS) {
-            if (field in fullObj) {
-                simplified[field] = fullObj[field];
-            }
-        }
-        const simplifiedJson = JSON.stringify(simplified, null, 2);
-        // ── 防线 3: str_replace 在简化 JSON 上精确匹配 ──
-        const matchCount = countOccurrences(simplifiedJson, oldStr);
-        if (matchCount === 0) {
-            throw new Error(`old_str not found in the simplified Portal JSON of rem ${remId}`);
-        }
-        if (matchCount > 1) {
-            throw new Error(`old_str matches ${matchCount} locations in Portal rem ${remId}. ` +
-                `Make old_str more specific to match exactly once.`);
-        }
-        const modifiedSimplifiedJson = simplifiedJson.replace(oldStr, newStr);
-        // JSON 解析
-        let modified;
-        try {
-            modified = JSON.parse(modifiedSimplifiedJson);
-        }
-        catch {
-            throw new Error('The replacement produced invalid JSON. Check your new_str for syntax errors.');
-        }
-        // 推导变更字段
-        const changes = {};
+        // ── 遍历 changes keys：分类过滤 ──
         const warnings = [];
-        for (const key of Object.keys(modified)) {
-            if (JSON.stringify(modified[key]) !== JSON.stringify(simplified[key])) {
-                if (PORTAL_READONLY_FIELDS.has(key)) {
-                    warnings.push(`Field '${key}' is read-only and was ignored`);
-                }
-                else {
-                    changes[key] = modified[key];
-                }
+        const writableChanges = {};
+        for (const key of Object.keys(changes)) {
+            if (READ_ONLY_FIELDS.has(key)) {
+                warnings.push(`Field '${key}' is read-only and was ignored`);
+            }
+            else if (!WRITABLE_FIELDS.has(key)) {
+                warnings.push(`Field '${key}' is unknown and was ignored`);
+            }
+            else {
+                writableChanges[key] = changes[key];
             }
         }
-        // 空变更检查
-        if (Object.keys(changes).length === 0) {
-            return { ok: true, changes: [], warnings };
-        }
-        // ── 发送变更到 Plugin ──
-        const writeResult = (await this.forwardToPlugin('write_rem_fields', {
-            remId,
-            changes,
-        }));
-        if (writeResult.failed) {
-            return {
-                ok: false,
-                changes: [],
-                warnings,
-                error: `Failed to update field '${writeResult.failed.field}': ${writeResult.failed.error}`,
-                appliedChanges: writeResult.applied,
-                failedField: writeResult.failed.field,
-            };
-        }
-        // ── 写入成功 → 从 Plugin 重新获取完整 Rem 并更新缓存（D5）──
-        const freshRemObject = await this.forwardToPlugin('read_rem', { remId });
-        const freshJson = JSON.stringify(freshRemObject, null, 2);
-        this.cache.set('rem:' + remId, freshJson);
-        return {
-            ok: true,
-            changes: Object.keys(changes),
-            warnings,
-        };
-    }
-    /** 普通 Rem 编辑路径：在完整 JSON 上执行 str_replace */
-    async handleNormalEdit(remId, cachedJson, original, oldStr, newStr) {
-        // ── 防线 3: str_replace 精确匹配 ──
-        const matchCount = countOccurrences(cachedJson, oldStr);
-        if (matchCount === 0) {
-            throw new Error(`old_str not found in the serialized JSON of rem ${remId}`);
-        }
-        if (matchCount > 1) {
-            throw new Error(`old_str matches ${matchCount} locations in rem ${remId}. ` +
-                `Make old_str more specific to match exactly once.`);
-        }
-        const modifiedJson = cachedJson.replace(oldStr, newStr);
-        // 1. JSON 解析
-        let modified;
-        try {
-            modified = JSON.parse(modifiedJson);
-        }
-        catch {
-            throw new Error('The replacement produced invalid JSON. Check your new_str for syntax errors.');
-        }
-        // 2. 推导变更字段
-        const changes = {};
-        const warnings = [];
-        for (const key of Object.keys(modified)) {
-            if (JSON.stringify(modified[key]) !== JSON.stringify(original[key])) {
-                if (READ_ONLY_FIELDS.has(key)) {
-                    warnings.push(`Field '${key}' is read-only and was ignored`);
-                }
-                else {
-                    changes[key] = modified[key];
+        // ── 枚举值范围校验 ──
+        for (const [field, allowedValues] of Object.entries(ENUM_VALUES)) {
+            if (field in writableChanges) {
+                const value = writableChanges[field];
+                if (!allowedValues.has(value)) {
+                    throw new Error(`Invalid value for '${field}': ${JSON.stringify(value)}. Allowed: ${[...allowedValues].map(v => JSON.stringify(v)).join(', ')}`);
                 }
             }
         }
-        // 3. 语义一致性校验
-        if ('todoStatus' in changes && changes.todoStatus !== null) {
-            const isTodo = modified.isTodo ?? original.isTodo;
+        // ── 语义校验：todoStatus 非 null 但 isTodo 未启用 ──
+        if ('todoStatus' in writableChanges && writableChanges.todoStatus !== null) {
+            const isTodo = writableChanges.isTodo ?? cachedObj.isTodo;
             if (!isTodo) {
                 warnings.push("Setting 'todoStatus' without 'isTodo: true' may have no effect");
             }
         }
-        // 4. 空变更检查
-        if (Object.keys(changes).length === 0) {
+        // ── 空变更检查 ──
+        if (Object.keys(writableChanges).length === 0) {
             return { ok: true, changes: [], warnings };
         }
         // ── 发送变更到 Plugin ──
         const writeResult = (await this.forwardToPlugin('write_rem_fields', {
             remId,
-            changes,
+            changes: writableChanges,
         }));
         if (writeResult.failed) {
             // 部分失败 — 不更新缓存（迫使 AI re-read）
@@ -193,27 +116,13 @@ export class EditHandler {
                 failedField: writeResult.failed.field,
             };
         }
-        // ── 写入成功 → 从 Plugin 重新获取完整 Rem 并更新缓存（D5）──
+        // ── 写入成功 → 从 Plugin 重新获取完整 Rem 并更新缓存 ──
         const freshRemObject = await this.forwardToPlugin('read_rem', { remId });
-        const freshJson = JSON.stringify(freshRemObject, null, 2);
-        this.cache.set('rem:' + remId, freshJson);
+        this.cache.set('rem:' + remId, freshRemObject);
         return {
             ok: true,
-            changes: Object.keys(changes),
+            changes: Object.keys(writableChanges),
             warnings,
         };
     }
 }
-/** 统计 needle 在 haystack 中出现的次数 */
-function countOccurrences(haystack, needle) {
-    let count = 0;
-    let pos = 0;
-    while (true) {
-        pos = haystack.indexOf(needle, pos);
-        if (pos === -1)
-            break;
-        count++;
-        pos += needle.length; // 非重叠匹配，与 String.replace 行为一致
-    }
-    return count;
-}

package/dist/cli/handlers/read-handler.js

@@ -44,17 +44,16 @@ export class ReadHandler {
         const includePowerup = payload.includePowerup ?? false;
         // 转发到 Plugin
         const remObject = await this.forwardToPlugin('read_rem', { remId, includePowerup });
-        // 缓存完整 JSON
-        const fullJson = JSON.stringify(remObject, null, 2);
-        this.cache.set(cacheKey, fullJson);
-        this.onLog?.(`缓存 Rem ${remId.slice(0, 8)}... (${fullJson.length} bytes)`, 'info');
+        // 缓存完整 RemObject 对象
+        this.cache.set(cacheKey, remObject);
+        this.onLog?.(`缓存 Rem ${remId.slice(0, 8)}...`, 'info');
         // 字段过滤
         const fields = payload.fields;
         const full = payload.full;
         let result;
         if (full) {
-            // --full → 返回完整对象（含 R-F 字段）
-            result = remObject;
+            // --full → 返回完整对象（含 R-F 字段）。浅拷贝避免污染缓存对象。
+            result = { ...remObject };
         }
         else if (fields) {
             // --fields 过滤：只返回指定字段 + id

package/dist/cli/handlers/rem-cache.js

@@ -1,8 +1,13 @@
 /**
- * RemCache — LRU 缓存，存储 Rem 的序列化 JSON
+ * RemCache — LRU 缓存，存储 Rem 数据
  *
  * 缓存存储在 daemon 内存中，生命周期与 daemon 一致。
  * disconnect 关闭 daemon → 缓存自然消失。
+ *
+ * 泛化值类型：不同 key 前缀存储不同类型的数据：
+ * - rem:{remId} → RemObject 对象
+ * - tree:{remId} → Markdown outline 字符串
+ * - tree-depth:{remId} 等 → 参数值字符串
  */
 export class RemCache {
     cache = new Map();
@@ -15,19 +20,19 @@ export class RemCache {
         if (!entry)
             return null;
         entry.lastAccess = Date.now();
-        return entry.json;
+        return entry.data;
     }
     /** 获取缓存条目的创建时间（ISO 8601），不存在返回 null */
     getCreatedAt(remId) {
         const entry = this.cache.get(remId);
         return entry ? entry.createdAt : null;
     }
-    set(remId, json) {
+    set(remId, data) {
         const now = Date.now();
         const createdAt = new Date(now).toISOString();
         if (this.cache.has(remId)) {
             const entry = this.cache.get(remId);
-            entry.json = json;
+            entry.data = data;
             entry.lastAccess = now;
             entry.createdAt = createdAt;
             return;
@@ -46,7 +51,7 @@ export class RemCache {
                 this.cache.delete(oldestId);
             }
         }
-        this.cache.set(remId, { json, lastAccess: now, createdAt });
+        this.cache.set(remId, { data, lastAccess: now, createdAt });
     }
     has(remId) {
         return this.cache.has(remId);

package/dist/cli/main.js

@@ -121,7 +121,7 @@ program
         const input = parseJsonInput('read-rem', remIdOrJson);
         if (!input)
             return;
-        await readRemCommand(input.remId, { json, fields: input.fields?.join(','), full: input.full, includePowerup: input.includePowerup });
+        await readRemCommand(input.remId, { json, fields: input.fields, full: input.full, includePowerup: input.includePowerup });
     }
     else {
         if (!remIdOrJson) {
@@ -282,7 +282,7 @@ program
             process.exitCode = 1;
             return;
         }
-        await searchCommand(input.query, { json, limit: input.numResults?.toString() });
+        await searchCommand(input.query, { json, limit: (input.limit ?? input.numResults)?.toString() });
     }
     else {
         if (!queryOrJson) {
@@ -295,16 +295,15 @@ program
 });
 program
     .command('edit-rem [remIdOrJson]')
-    .description('通过 str_replace 编辑 Rem 的 JSON 字段')
-    .option('--old-str <oldStr>', '要替换的原始文本片段')
-    .option('--new-str <newStr>', '替换后的新文本片段')
+    .description('直接修改 Rem 的属性字段')
+    .option('--changes <changesJson>', '要修改的字段及新值（JSON 字符串）')
     .action(async (remIdOrJson, cmdOpts) => {
     const { json } = program.opts();
     if (json) {
-        const input = parseJsonInput('edit-rem', remIdOrJson, ['oldStr', 'newStr']);
+        const input = parseJsonInput('edit-rem', remIdOrJson, ['changes']);
         if (!input)
             return;
-        await editRemCommand(input.remId, { json, oldStr: input.oldStr, newStr: input.newStr });
+        await editRemCommand(input.remId, { json, changes: input.changes });
     }
     else {
         if (!remIdOrJson) {
@@ -312,12 +311,21 @@ program
             process.exitCode = 1;
             return;
         }
-        if (!cmdOpts.oldStr || cmdOpts.newStr === undefined) {
-            console.error('错误: --old-str 和 --new-str 是必需的');
+        if (!cmdOpts.changes) {
+            console.error('错误: --changes 是必需的');
+            process.exitCode = 1;
+            return;
+        }
+        let changes;
+        try {
+            changes = JSON.parse(cmdOpts.changes);
+        }
+        catch {
+            console.error('错误: --changes 不是合法的 JSON');
             process.exitCode = 1;
             return;
         }
-        await editRemCommand(remIdOrJson, { json, oldStr: cmdOpts.oldStr, newStr: cmdOpts.newStr });
+        await editRemCommand(remIdOrJson, { json, changes });
     }
 });
 // mcp 子命令

package/dist/mcp/format.js

@@ -0,0 +1,43 @@
+/**
+ * MCP 返回值格式化工具
+ *
+ * 两种模式：
+ * - formatFrontmatter：YAML frontmatter + body（read 类工具）
+ * - formatDataJson：剥离 wrapper 的 JSON（action/infra 工具）
+ */
+// ---------------------------------------------------------------------------
+// 模式 A：Frontmatter + Body
+// ---------------------------------------------------------------------------
+/**
+ * 将元数据序列化为 YAML frontmatter，拼接 body 内容。
+ *
+ * - null/undefined 的值自动跳过
+ * - 数字/布尔：裸值（`nodeCount: 42`）
+ * - 字符串：JSON 引号（`mode: "focus"`）
+ * - 数组/对象：JSON 内联（`ancestors: [{"id":"x"}]`）
+ * - 无元数据时省略 `---` 分隔符，直接返回 body
+ */
+export function formatFrontmatter(meta, body) {
+    const entries = Object.entries(meta).filter(([, v]) => v !== undefined && v !== null);
+    if (entries.length === 0)
+        return body;
+    const lines = entries.map(([k, v]) => {
+        if (typeof v === 'number' || typeof v === 'boolean')
+            return `${k}: ${v}`;
+        return `${k}: ${JSON.stringify(v)}`;
+    });
+    return `---\n${lines.join('\n')}\n---\n\n${body}`;
+}
+// ---------------------------------------------------------------------------
+// 模式 B：Data JSON（剥离 ok/command/timestamp wrapper）
+// ---------------------------------------------------------------------------
+/**
+ * 从 CLI 响应中剥离 ok/command/timestamp，返回剩余字段的 JSON。
+ *
+ * 用于 action/infra 工具——AI 不需要看到冗余的 wrapper 字段。
+ * callCli 已在 ok===false 时抛出 CliError，成功路径 ok 始终为 true。
+ */
+export function formatDataJson(response) {
+    const { ok: _ok, command: _cmd, timestamp: _ts, ...rest } = response;
+    return JSON.stringify(rest, null, 2);
+}

package/dist/mcp/index.js

@@ -9,12 +9,6 @@ import { SERVER_INSTRUCTIONS } from './instructions.js';
 import { registerReadTools } from './tools/read-tools.js';
 import { registerEditTools } from './tools/edit-tools.js';
 import { registerInfraTools } from './tools/infra-tools.js';
-import { OUTLINE_FORMAT_CONTENT } from './resources/outline-format.js';
-import { REM_OBJECT_FIELDS_CONTENT } from './resources/rem-object-fields.js';
-import { EDIT_REM_GUIDE_CONTENT } from './resources/edit-rem-guide.js';
-import { EDIT_TREE_GUIDE_CONTENT } from './resources/edit-tree-guide.js';
-import { ERROR_REFERENCE_CONTENT } from './resources/error-reference.js';
-import { SEPARATOR_FLASHCARD_CONTENT } from './resources/separator-flashcard.js';
 export async function startMcpServer() {
     const server = new FastMCP({
         name: 'remnote-bridge',
@@ -24,54 +18,5 @@ export async function startMcpServer() {
     registerInfraTools(server);
     registerReadTools(server);
     registerEditTools(server);
-    // Resources
-    server.addResource({
-        uri: 'remnote://outline-format',
-        name: 'Markdown 大纲格式规范',
-        mimeType: 'text/markdown',
-        async load() {
-            return { text: OUTLINE_FORMAT_CONTENT };
-        },
-    });
-    server.addResource({
-        uri: 'remnote://rem-object-fields',
-        name: 'RemObject 字段完整参考',
-        mimeType: 'text/markdown',
-        async load() {
-            return { text: REM_OBJECT_FIELDS_CONTENT };
-        },
-    });
-    server.addResource({
-        uri: 'remnote://edit-rem-guide',
-        name: 'edit_rem 操作指南',
-        mimeType: 'text/markdown',
-        async load() {
-            return { text: EDIT_REM_GUIDE_CONTENT };
-        },
-    });
-    server.addResource({
-        uri: 'remnote://edit-tree-guide',
-        name: 'edit_tree 操作指南',
-        mimeType: 'text/markdown',
-        async load() {
-            return { text: EDIT_TREE_GUIDE_CONTENT };
-        },
-    });
-    server.addResource({
-        uri: 'remnote://error-reference',
-        name: '错误诊断与恢复参考',
-        mimeType: 'text/markdown',
-        async load() {
-            return { text: ERROR_REFERENCE_CONTENT };
-        },
-    });
-    server.addResource({
-        uri: 'remnote://separator-flashcard',
-        name: '分隔符与闪卡参考',
-        mimeType: 'text/markdown',
-        async load() {
-            return { text: SEPARATOR_FLASHCARD_CONTENT };
-        },
-    });
     await server.start({ transportType: 'stdio' });
 }