dingtalk-wiki 1.1.3 → 1.1.5

package/index.js

@@ -52,6 +52,64 @@ function loadEnvFile(filePath) {
   return true;
 }
 
+function getElementsText(elements) {
+  if (!elements || !Array.isArray(elements)) return '';
+  return elements.map(el => {
+    if (el.textRun?.content) return el.textRun.content;
+    if (el.paragraphRun?.richText?.elements) return getElementsText(el.paragraphRun.richText.elements);
+    return '';
+  }).join('');
+}
+
+function extractBlockText(block) {
+  const getText = () => {
+    switch (block.blockType) {
+      case 'paragraph':
+        return getElementsText(block.paragraph?.richText?.elements);
+      case 'heading': {
+        const level = block.heading?.headingType || 1;
+        const headingText = getElementsText(block.heading?.richText?.elements);
+        return `${'#'.repeat(level)} ${headingText}`;
+      }
+      case 'table': {
+        const table = block.table;
+        if (!table?.cells) return '[空表格]';
+        const cellTexts = table.cells.map(cell => {
+          const cellBlocks = cell.blocks || [];
+          return cellBlocks.map(cb => extractBlockText(cb)).join(' | ');
+        });
+        const colCount = table.columnsCount || (table.cells[0]?.blocks?.length || 1);
+        const rows = [];
+        let currentRow = [];
+        cellTexts.forEach((t, i) => {
+          currentRow.push(t);
+          if (currentRow.length === colCount) {
+            rows.push(currentRow.join(' | '));
+            currentRow = [];
+          }
+        });
+        if (currentRow.length) rows.push(currentRow.join(' | '));
+        return rows.map(r => `| ${r} |`).join('\n');
+      }
+      case 'unorderedList':
+        return `• ${getElementsText(block.unorderedList?.richText?.elements)}`;
+      case 'orderedList':
+        return `1. ${getElementsText(block.orderedList?.richText?.elements)}`;
+      case 'blockquote':
+        return `> ${getElementsText(block.blockquote?.richText?.elements)}`;
+      case 'codeBlock':
+        return '```\n' + getElementsText(block.codeBlock?.richText?.elements) + '\n```';
+      case 'divider':
+        return '---';
+      case 'image':
+        return `[图片: ${block.image?.caption || ''}]`;
+      default:
+        return `[${block.blockType}] ${getElementsText(block.paragraph?.richText?.elements)}`;
+    }
+  };
+  return getText();
+}
+
 const DOTENV_CANDIDATES = [
   process.env.DINGTALK_WIKI_ENV_PATH,
   path.join(process.cwd(), '.env'),
@@ -228,6 +286,33 @@ class DingTalkClient {
     return this.operatorId;
   }
 
+  async docRequest(method, pathName, { operatorId = null, data = null } = {}) {
+    const token = await this.getAccessToken();
+    const resolvedOperatorId = await this.resolveOperatorId(operatorId);
+    const url = `${DINGTALK_API_V2}${pathName}`;
+
+    try {
+      const response = await axios({
+        method,
+        url,
+        headers: {
+          'x-acs-dingtalk-access-token': token,
+          'Content-Type': 'application/json'
+        },
+        params: {
+          operatorId: resolvedOperatorId
+        },
+        data
+      });
+      return response.data;
+    } catch (error) {
+      if (error.response) {
+        throw new Error(`${error.response.data?.message || error.message} (code: ${error.response.data?.code})`);
+      }
+      throw error;
+    }
+  }
+
   async notableRequest(method, pathName, { operatorId = null, params = {}, data = null } = {}) {
     const token = await this.getAccessToken();
     const resolvedOperatorId = await this.resolveOperatorId(operatorId);
@@ -332,6 +417,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             workspace_id: {
               type: 'string',
               description: '知识库工作空间 ID'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
             }
           },
           required: ['workspace_id']
@@ -349,7 +438,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             parent_node_id: {
               type: 'string',
-              description: '父节点 ID（不传则获取根目录）'
+              description: '父节点 ID（不传则列出根目录节点）'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
             }
           },
           required: ['workspace_id']
@@ -371,9 +464,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             doc_type: {
               type: 'string',
-              description: '文档类型: DOC(文字), WORKBOOK(表格), MIND(脑图), FOLDER(文件夹)',
-              enum: ['DOC', 'WORKBOOK', 'MIND', 'FOLDER'],
-              default: 'DOC'
+              description: '文档类型，可选: DOC / WORKBOOK / MIND / FOLDER（默认 DOC）'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
             },
             parent_node_id: {
               type: 'string',
@@ -396,6 +491,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             node_id: {
               type: 'string',
               description: '节点 ID'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
             }
           },
           required: ['node_id']
@@ -403,7 +502,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'search_wiki',
-        description: '搜索知识库内容',
+        description: '搜索知识库（POST /v2.0/doc/search）',
         inputSchema: {
           type: 'object',
           properties: {
@@ -414,6 +513,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             workspace_id: {
               type: 'string',
               description: '指定知识库 ID（可选）'
+            },
+            max_results: {
+              type: 'number',
+              description: '返回条数上限（默认 10，最大 20）'
+            },
+            next_token: {
+              type: 'string',
+              description: '分页游标（上次返回的 nextToken）'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
             }
           },
           required: ['keyword']
@@ -476,6 +587,255 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ['userid']
         }
       },
+      {
+        name: 'get_wiki_doc_content',
+        description: '读取文档正文内容（返回 Block 结构，含标题、段落、表格等）',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            doc_key: {
+              type: 'string',
+              description: '文档 docKey。wiki nodes 返回的 nodeId 本质是 dentryUuid，可直接用于此处'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['doc_key']
+        }
+      },
+      {
+        name: 'update_wiki_doc_content',
+        description: '覆写文档正文内容（⚠️ 全量覆盖，不可撤销）',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            doc_key: {
+              type: 'string',
+              description: '文档 docKey。wiki nodes 返回的 nodeId 本质是 dentryUuid，可直接用于此处'
+            },
+            content: {
+              type: 'string',
+              description: '要写入的 Markdown 内容'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['doc_key', 'content']
+        }
+      },
+      {
+        name: 'rename_wiki_doc',
+        description: '重命名文档',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            workspace_id: {
+              type: 'string',
+              description: '知识库工作空间 ID'
+            },
+            node_id: {
+              type: 'string',
+              description: '节点 ID（重命名的目标文档）'
+            },
+            name: {
+              type: 'string',
+              description: '新的文档名称'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['workspace_id', 'node_id', 'name']
+        }
+      },
+      {
+        name: 'delete_wiki_doc',
+        description: '删除文档节点',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            workspace_id: {
+              type: 'string',
+              description: '知识库工作空间 ID'
+            },
+            node_id: {
+              type: 'string',
+              description: '节点 ID（要删除的目标文档）'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['workspace_id', 'node_id']
+        }
+      },
+      {
+        name: 'create_notable_record',
+        description: '在 AI 表格数据表中创建一条或多条记录',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            base_id: {
+              type: 'string',
+              description: 'Notable baseId'
+            },
+            sheet_id: {
+              type: 'string',
+              description: '数据表 ID 或名称，可通过 list_notable_sheets 获取'
+            },
+            records: {
+              type: 'array',
+              description: '要创建的记录数组。每条记录为 { fields: { 字段名: 值 } }',
+              items: {
+                type: 'object',
+                properties: {
+                  fields: {
+                    type: 'object',
+                    description: '字段名到字段值的映射'
+                  }
+                },
+                required: ['fields']
+              }
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['base_id', 'sheet_id', 'records']
+        }
+      },
+      {
+        name: 'update_notable_record',
+        description: '更新 AI 表格数据表中的多条记录',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            base_id: {
+              type: 'string',
+              description: 'Notable baseId'
+            },
+            sheet_id: {
+              type: 'string',
+              description: '数据表 ID 或名称'
+            },
+            records: {
+              type: 'array',
+              description: '要更新的记录数组。每条记录格式为 { id: "recordId", fields: { 字段名: 值 } }',
+              items: {
+                type: 'object',
+                properties: {
+                  id: {
+                    type: 'string',
+                    description: '记录 ID'
+                  },
+                  fields: {
+                    type: 'object',
+                    description: '要更新的字段'
+                  }
+                },
+                required: ['id', 'fields']
+              }
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['base_id', 'sheet_id', 'records']
+        }
+      },
+      {
+        name: 'delete_notable_record',
+        description: '删除 AI 表格数据表中的多条记录',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            base_id: {
+              type: 'string',
+              description: 'Notable baseId'
+            },
+            sheet_id: {
+              type: 'string',
+              description: '数据表 ID 或名称'
+            },
+            record_ids: {
+              type: 'array',
+              description: '要删除的记录 ID 列表',
+              items: {
+                type: 'string'
+              }
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['base_id', 'sheet_id', 'record_ids']
+        }
+      },
+      {
+        name: 'create_notable_sheet',
+        description: '在 AI 表格中创建一个新的数据表',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            base_id: {
+              type: 'string',
+              description: 'Notable baseId'
+            },
+            name: {
+              type: 'string',
+              description: '数据表名称'
+            },
+            fields: {
+              type: 'array',
+              description: '数据表字段配置（可选），格式: [{ name: "字段名", type: "字段类型", property: {} }]',
+              items: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string', description: '字段名' },
+                  type: { type: 'string', description: '字段类型，如 Text, Number, Select 等' }
+                },
+                required: ['name', 'type']
+              }
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['base_id', 'name']
+        }
+      },
+      {
+        name: 'delete_notable_sheet',
+        description: '删除 AI 表格中的一个数据表',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            base_id: {
+              type: 'string',
+              description: 'Notable baseId'
+            },
+            sheet_id: {
+              type: 'string',
+              description: '数据表 ID 或名称'
+            },
+            operator_id: {
+              type: 'string',
+              description: '操作者 unionid（不传则使用默认用户）'
+            }
+          },
+          required: ['base_id', 'sheet_id']
+        }
+      },
       {
         name: 'list_notable_sheets',
         description: '读取 AI 表格 / Notable 的所有数据表。对于 .able 节点，直接使用 nodeId 作为 base_id。',
@@ -560,8 +920,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'get_wiki_workspace': {
-        const { workspace_id } = args;
-        // 通过列表获取详情
+        const { workspace_id, operator_id } = args;
+        if (operator_id) {
+          dingtalk.setOperatorId(operator_id);
+        }
         const result = await dingtalk.wikiRequest('workspaces');
         const workspaces = result.workspaces || [];
         const workspace = workspaces.find(ws => ws.workspaceId === workspace_id);
@@ -732,24 +1094,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       case 'get_wiki_node': {
-        const { node_id } = args;
-        // 通过搜索或其他方式获取节点详情
+        const { node_id, operator_id } = args;
+        if (operator_id) {
+          dingtalk.setOperatorId(operator_id);
+        }
+        const result = await dingtalk.docRequest('GET', `/v2.0/wiki/nodes/${node_id}`, {
+          operatorId: operator_id || null
+        });
+        const node = result;
+        let output = `📄 节点详情\n\n`;
+        output += `名称: ${node.name || '-'}\n`;
+        output += `ID: ${node.id || node.nodeId || '-'}\n`;
+        output += `类型: ${node.type || '-'}\n`;
+        output += `知识库 ID: ${node.workspaceId || '-'}\n`;
+        output += `父节点: ${node.parentNodeId || '-'}\n`;
+        output += `创建时间: ${node.createdTime || '-'}\n`;
+        output += `修改时间: ${node.modifiedTime || '-'}\n`;
+        output += `URL: ${node.url || '-'}\n`;
+        if (node.document) {
+          output += `文档信息: ${JSON.stringify(node.document)}\n`;
+        }
         return {
-          content: [{
-            type: 'text',
-            text: `📄 节点 ID: ${node_id}\n\n请使用 list_wiki_nodes 获取节点列表，然后通过节点链接访问详情。`
-          }]
+          content: [{ type: 'text', text: output }]
         };
       }
 
       case 'search_wiki': {
-        const { keyword, workspace_id } = args;
-        // Wiki 搜索 API 需要额外权限
+        const { keyword, workspace_id, max_results = 10, next_token, operator_id } = args;
+        if (operator_id) {
+          dingtalk.setOperatorId(operator_id);
+        }
+        const body = {
+          keyword,
+          maxResults: Math.min(max_results, 20)
+        };
+        if (next_token) {
+          body.nextToken = next_token;
+        }
+        if (workspace_id) {
+          body.option = { workspaceIds: [workspace_id] };
+        }
+        const result = await dingtalk.docRequest('POST', '/v2.0/doc/search', {
+          operatorId: operator_id || null,
+          data: body
+        });
+        const items = result.items || [];
+        let output = `🔍 搜索 "${keyword}" (${items.length}条)\n\n`;
+        items.forEach((item, i) => {
+          output += `${i + 1}. ${item.name}\n`;
+          output += `   知识库: ${item.workspaceId}\n`;
+          output += `   链接: ${item.url}\n\n`;
+        });
+        if (!items.length) {
+          output += '没有找到匹配的知识库。\n';
+        }
+        if (result.nextToken) {
+          output += `--- 更多结果, nextToken: ${result.nextToken} ---\n`;
+        }
         return {
-          content: [{
-            type: 'text',
-            text: `🔍 搜索知识库: ${keyword}\n\n搜索功能需要 Wiki.Search 权限。\n\n请直接访问知识库网页版进行搜索：\nhttps://alidocs.dingtalk.com/i/spaces/${workspace_id || ''}/search?keyword=${encodeURIComponent(keyword)}`
-          }]
+          content: [{ type: 'text', text: output }]
         };
       }
 
@@ -803,6 +1206,73 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      case 'get_wiki_doc_content': {
+        const { doc_key: docKey, operator_id } = args;
+        if (operator_id) {
+          dingtalk.setOperatorId(operator_id);
+        }
+        const result = await dingtalk.docRequest('GET', `/v1.0/doc/suites/documents/${docKey}/blocks`, { operatorId: operator_id || null });
+        const blocks = result.result?.data || [];
+        let output = '';
+        blocks.forEach((block) => {
+          const text = extractBlockText(block);
+          output += text + '\n\n';
+        });
+        if (!blocks.length) {
+          output = '（文档为空或无可读内容）';
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: output.trim()
+          }]
+        };
+      }
+
+      case 'update_wiki_doc_content': {
+        const { doc_key: docKey, content, operator_id } = args;
+        if (operator_id) {
+          dingtalk.setOperatorId(operator_id);
+        }
+        await dingtalk.docRequest('POST', `/v1.0/doc/suites/documents/${docKey}/overwriteContent`, {
+          operatorId: operator_id || null,
+          data: { content, contentType: 'markdown' }
+        });
+        return {
+          content: [{ type: 'text', text: '✅ 文档内容已更新' }]
+        };
+      }
+
+      case 'rename_wiki_doc': {
+        const { workspace_id, node_id, name, operator_id } = args;
+        if (operator_id) {
+          dingtalk.setOperatorId(operator_id);
+        }
+        await dingtalk.docRequest('PATCH', `/v1.0/doc/workspaces/${workspace_id}/docs/${node_id}`, {
+          operatorId: operator_id || null,
+          data: { name }
+        });
+        return {
+          content: [{ type: 'text', text: `✅ 文档已重命名为: ${name}` }]
+        };
+      }
+
+      case 'delete_wiki_doc': {
+        const { workspace_id, node_id, operator_id } = args;
+        if (operator_id) {
+          dingtalk.setOperatorId(operator_id);
+        }
+        await dingtalk.docRequest('DELETE', `/v1.0/doc/workspaces/${workspace_id}/docs/${node_id}`, {
+          operatorId: operator_id || null
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: `✅ 文档已删除 (nodeId: ${node_id})`
+          }]
+        };
+      }
+
       case 'list_notable_sheets': {
         const { base_id, operator_id } = args;
         const result = await dingtalk.notableRequest('GET', `/v1.0/notable/bases/${base_id}/sheets`, {
@@ -853,6 +1323,79 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      case 'create_notable_record': {
+        const { base_id, sheet_id, records, operator_id } = args;
+        const result = await dingtalk.notableRequest('POST', `/v1.0/notable/bases/${base_id}/sheets/${sheet_id}/records`, {
+          operatorId: operator_id || null,
+          data: { records }
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: `✅ 已创建 ${records.length} 条记录\n\n${JSON.stringify(result, null, 2)}`
+          }]
+        };
+      }
+
+      case 'update_notable_record': {
+        const { base_id, sheet_id, records, operator_id } = args;
+        const result = await dingtalk.notableRequest('PUT', `/v1.0/notable/bases/${base_id}/sheets/${sheet_id}/records`, {
+          operatorId: operator_id || null,
+          data: { records }
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: `✅ 已更新 ${records.length} 条记录\n\n${JSON.stringify(result, null, 2)}`
+          }]
+        };
+      }
+
+      case 'delete_notable_record': {
+        const { base_id, sheet_id, record_ids, operator_id } = args;
+        const result = await dingtalk.notableRequest('DELETE', `/v1.0/notable/bases/${base_id}/sheets/${sheet_id}/records`, {
+          operatorId: operator_id || null,
+          data: { recordIds: record_ids }
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: `✅ 已删除 ${record_ids.length} 条记录`
+          }]
+        };
+      }
+
+      case 'create_notable_sheet': {
+        const { base_id, name, fields, operator_id } = args;
+        const data = { name };
+        if (fields) {
+          data.fields = fields;
+        }
+        const result = await dingtalk.notableRequest('POST', `/v1.0/notable/bases/${base_id}/sheets`, {
+          operatorId: operator_id || null,
+          data
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: `✅ 数据表已创建\n\n${JSON.stringify(result, null, 2)}`
+          }]
+        };
+      }
+
+      case 'delete_notable_sheet': {
+        const { base_id, sheet_id, operator_id } = args;
+        await dingtalk.notableRequest('DELETE', `/v1.0/notable/bases/${base_id}/sheets/${sheet_id}`, {
+          operatorId: operator_id || null
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: `✅ 数据表已删除 (sheetId: ${sheet_id})`
+          }]
+        };
+      }
+
       default:
         throw new Error(`未知工具: ${name}`);
     }
@@ -872,7 +1415,7 @@ async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error('钉钉 Wiki MCP Server 已启动 v2.0');
-  console.error(`Config path: ${CONFIG_PATH}`);
+  console.error(`Config via DINGTALK_WIKI_CONFIG env var`);
 }
 
 main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dingtalk-wiki",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "DingTalk Wiki / Docs read-write MCP server that fills the gap left by DingTalk official MCP.",
   "main": "index.js",
   "bin": {

package/skill/SKILL.md

@@ -7,10 +7,19 @@
 - `get_wiki_workspace` - 获取知识库详情
 - `list_wiki_nodes` - 列出知识库节点（文档 / 目录）
 - `get_wiki_node` - 获取节点详情
+- `get_wiki_doc_content` - 读取文档正文内容（Block 结构）
 - `create_wiki_doc` - 创建文档（支持 `DOC` / `WORKBOOK` / `MIND` / `FOLDER`）
+- `update_wiki_doc_content` - 覆写文档内容（Markdown，⚠️ 全量覆盖）
+- `rename_wiki_doc` - 重命名文档
+- `delete_wiki_doc` - 删除文档节点
 - `search_wiki` - 搜索知识库内容
 - `list_notable_sheets` - 获取 `.able` / AI 表格中的所有数据表
 - `list_notable_records` - 获取指定数据表中的 records
+- `create_notable_record` - 创建记录（单条或多条）
+- `update_notable_record` - 更新记录
+- `delete_notable_record` - 删除记录
+- `create_notable_sheet` - 创建数据表
+- `delete_notable_sheet` - 删除数据表
 
 ### 组织架构
 - `list_departments` - 列出部门列表
@@ -72,11 +81,36 @@ mcporter call dingtalk-wiki.create_wiki_doc \
 # 获取节点详情
 mcporter call dingtalk-wiki.get_wiki_node node_id="your_node_id"
 
-# 搜索知识库内容
+# 读取文档正文内容
+mcporter call dingtalk-wiki.get_wiki_doc_content doc_key="your_doc_key"
+
+# 更新文档内容（Markdown，⚠️ 全量覆盖）
+mcporter call dingtalk-wiki.update_wiki_doc_content \
+  doc_key="your_doc_key" \
+  content="# 新标题\n\n新正文"
+
+# 重命名文档
+mcporter call dingtalk-wiki.rename_wiki_doc \
+  workspace_id="your_workspace_id" \
+  node_id="your_node_id" \
+  name="新文档名称"
+
+# 删除文档
+mcporter call dingtalk-wiki.delete_wiki_doc \
+  workspace_id="your_workspace_id" \
+  node_id="your_node_id"
+
+# 搜索知识库
 mcporter call dingtalk-wiki.search_wiki keyword="项目规划"
 
 # 在指定知识库内搜索
 mcporter call dingtalk-wiki.search_wiki keyword="项目规划" workspace_id="your_workspace_id"
+
+# 自定义返回条数
+mcporter call dingtalk-wiki.search_wiki keyword="项目规划" max_results=5
+
+# 分页搜索
+mcporter call dingtalk-wiki.search_wiki keyword="项目规划" next_token="your_next_token"
 ```
 
 ### AI 表格（Notable）
@@ -101,6 +135,40 @@ mcporter call dingtalk-wiki.list_notable_records \
   base_id="your_base_id" \
   sheet_id="your_sheet_id" \
   next_token="your_next_token"
+
+# 创建记录（单条或多条）
+mcporter call dingtalk-wiki.create_notable_record \
+  base_id="your_base_id" \
+  sheet_id="your_sheet_id" \
+  records='[{"fields":{"姓名":"张三","年龄":25}}]'
+
+# 更新记录
+mcporter call dingtalk-wiki.update_notable_record \
+  base_id="your_base_id" \
+  sheet_id="your_sheet_id" \
+  records='[{"id":"record_id","fields":{"姓名":"李四","年龄":26}}]'
+
+# 删除记录
+mcporter call dingtalk-wiki.delete_notable_record \
+  base_id="your_base_id" \
+  sheet_id="your_sheet_id" \
+  record_ids='["record_id1","record_id2"]'
+
+# 创建数据表
+mcporter call dingtalk-wiki.create_notable_sheet \
+  base_id="your_base_id" \
+  name="新数据表"
+
+# 创建带字段的数据表
+mcporter call dingtalk-wiki.create_notable_sheet \
+  base_id="your_base_id" \
+  name="员工表" \
+  fields='[{"name":"姓名","type":"Text"},{"name":"年龄","type":"Number"}]'
+
+# 删除数据表
+mcporter call dingtalk-wiki.delete_notable_sheet \
+  base_id="your_base_id" \
+  sheet_id="your_sheet_id"
 ```
 
 ### 组织架构