@xiedada/nodemw-mcp-server 0.1.0 → 0.1.2

package/dist/index.js

@@ -37,8 +37,16 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 // package.json
 var package_default = {
   name: "@xiedada/nodemw-mcp-server",
-  version: "0.1.0",
+  version: "0.1.2",
   description: "MCP server for nodemw - MediaWiki API client",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/TimXiedada/nodemw-mcp.git"
+  },
+  bugs: {
+    url: "https://github.com/TimXiedada/nodemw-mcp/issues"
+  },
+  homepage: "https://github.com/TimXiedada/nodemw-mcp#readme",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -239,13 +247,13 @@ async function requireRead(title) {
 }
 
 // src/tools/ro/get-article.ts
-async function recordReadState(title) {
+async function recordReadState(identifier) {
   try {
     const bot = await getBot();
     const pages = await promisifyBotMethod(
       bot,
       "getArticleInfo",
-      title,
+      identifier,
       { prop: "info" }
     );
     const page = Array.isArray(pages) ? pages[0] : null;
@@ -267,8 +275,9 @@ function getArticleTool(server) {
     "get-article",
     "Retrieve the content of a wiki article",
     {
-      title: z.string().describe("Article title"),
-      followRedirect: z.boolean().optional().default(true).describe("Follow redirects"),
+      title: z.string().optional().describe('Article title (required if "id" is not provided)'),
+      id: z.number().optional().describe('Page ID (required if "title" is not provided)'),
+      followRedirect: z.boolean().optional().default(true).describe('Follow redirects (only applies when using "title")'),
       redirectInfo: z.boolean().optional().default(false).describe("Include information about redirects"),
       revision: z.number().optional().describe("Specific revision ID to fetch. If omitted, returns the latest version.")
     },
@@ -277,21 +286,35 @@ function getArticleTool(server) {
       readOnlyHint: true,
       destructiveHint: false
     },
-    async ({ title, followRedirect, redirectInfo, revision }) => handleGetArticleTool(title, followRedirect, redirectInfo, revision)
+    async ({ title, id, followRedirect, redirectInfo, revision }) => handleGetArticleTool(title, id, followRedirect, redirectInfo, revision)
   );
 }
-async function handleGetArticleTool(title, followRedirect, redirectInfo, revision) {
+async function handleGetArticleTool(title, id, followRedirect, redirectInfo, revision) {
   try {
     const bot = await getBot();
-    if (revision !== void 0) {
+    if (!title && id == null) {
+      return {
+        content: [{ type: "text", text: 'Either "title" or "id" must be provided.' }],
+        isError: true
+      };
+    }
+    if (title && id != null) {
+      return {
+        content: [{ type: "text", text: 'Provide either "title" or "id", not both.' }],
+        isError: true
+      };
+    }
+    const useDirectApi = revision !== void 0 || id !== void 0;
+    if (useDirectApi) {
       const params = {
         action: "query",
         prop: "revisions",
         rvprop: "content",
-        rvstartid: revision,
         rvlimit: 1,
-        titles: title,
-        ...followRedirect && { redirects: "" }
+        ...id !== void 0 ? { pageids: id } : { titles: title },
+        ...revision !== void 0 && { rvstartid: revision },
+        // redirects param is ignored by MW API when pageids is used
+        ...id === void 0 && followRedirect && { redirects: "" }
       };
       const info = await new Promise((resolve, reject) => {
         bot.api.call(params, (err, info2) => {
@@ -302,22 +325,38 @@ async function handleGetArticleTool(title, followRedirect, redirectInfo, revisio
       const pages = info.pages;
       const page = getFirstItem(pages);
       if (!page || page.missing !== void 0) {
+        const identifier = title ?? `id ${id}`;
         return {
-          content: [{ type: "text", text: `Page "${title}" not found.` }],
+          content: [{ type: "text", text: `Page "${identifier}" not found.` }],
           isError: true
         };
       }
+      if (revision !== void 0) {
+        const revisions2 = page.revisions;
+        const rev = revisions2?.[0];
+        if (!rev || rev["*"] == null) {
+          const identifier = title ?? `id ${id}`;
+          return {
+            content: [{ type: "text", text: `Revision ${revision} not found for page "${identifier}".` }],
+            isError: true
+          };
+        }
+        await recordReadState(id ?? title);
+        return {
+          content: [{ type: "text", text: rev["*"] }]
+        };
+      }
       const revisions = page.revisions;
-      const rev = revisions?.[0];
-      if (!rev || rev["*"] == null) {
+      const content = revisions?.[0]?.["*"];
+      if (content == null) {
         return {
-          content: [{ type: "text", text: `Revision ${revision} not found for page "${title}".` }],
-          isError: true
+          content: [{ type: "text", text: page.title ? `Page "${page.title}" is empty.` : `Page ID ${id} is empty.` }],
+          isError: false
         };
       }
-      await recordReadState(title);
+      await recordReadState(id ?? title);
       return {
-        content: [{ type: "text", text: rev["*"] }]
+        content: [{ type: "text", text: content === "" ? "(empty page)" : content }]
       };
     }
     if (redirectInfo) {
@@ -712,21 +751,73 @@ function getArticleRevisionsTool(server) {
     "get-article-revisions",
     "Get all revisions of a wiki article",
     {
-      title: z10.union([z10.string(), z10.number()]).describe("Article title or page ID")
+      title: z10.string().optional().describe('Article title (required if "id" is not provided)'),
+      id: z10.number().optional().describe('Page ID (required if "title" is not provided)')
     },
     {
       title: "Get article revisions",
       readOnlyHint: true,
       destructiveHint: false
     },
-    async ({ title }) => handleGetArticleRevisionsTool(title)
+    async ({ title, id }) => handleGetArticleRevisionsTool(title, id)
   );
-  tool.update({ outputSchema: { title: z10.string(), revisions: z10.array(z10.record(z10.unknown())), count: z10.number() } });
+  tool.update({ outputSchema: { identifier: z10.union([z10.string(), z10.number()]), revisions: z10.array(z10.record(z10.unknown())), count: z10.number() } });
   return tool;
 }
-async function handleGetArticleRevisionsTool(title) {
+async function apiCall(bot, params) {
+  return new Promise((resolve, reject) => {
+    bot.api.call(
+      params,
+      (err, data) => {
+        if (err) reject(err);
+        else resolve(data);
+      },
+      "GET"
+    );
+  });
+}
+async function handleGetArticleRevisionsTool(title, id) {
   try {
+    if (!title && id == null) {
+      return errorResult('Either "title" or "id" must be provided');
+    }
+    if (title && id != null) {
+      return errorResult('Provide either "title" or "id", not both');
+    }
     const bot = await getBot();
+    if (id !== void 0) {
+      const allRevisions2 = [];
+      let rvcontinue;
+      do {
+        const params = {
+          action: "query",
+          prop: "revisions",
+          pageids: id,
+          rvprop: "ids|timestamp|user|comment|size",
+          rvlimit: 500,
+          rvdir: "older"
+        };
+        if (rvcontinue) {
+          params.rvcontinue = rvcontinue;
+        }
+        const result = await apiCall(bot, params);
+        const pages = result.pages;
+        if (!pages) break;
+        const pageId = String(id);
+        const page = pages[pageId];
+        if (!page || page.missing !== void 0) break;
+        const revs = page.revisions;
+        if (revs) {
+          allRevisions2.push(...revs);
+        }
+        rvcontinue = result.continue?.rvcontinue;
+      } while (rvcontinue && allRevisions2.length < 1e4);
+      return jsonResult({
+        identifier: id,
+        revisions: allRevisions2,
+        count: allRevisions2.length
+      });
+    }
     const allRevisions = await promisifyBotMethod(
       bot,
       "getArticleRevisions",
@@ -734,7 +825,7 @@ async function handleGetArticleRevisionsTool(title) {
     );
     const revisions = allRevisions.flat().filter((rev) => rev != null);
     return jsonResult({
-      title,
+      identifier: title,
       revisions,
       count: revisions.length
     });
@@ -750,21 +841,59 @@ function getArticleCategoriesTool(server) {
     "get-article-categories",
     "Get all categories that an article belongs to",
     {
-      title: z11.union([z11.string(), z11.number()]).describe("Article title or page ID")
+      title: z11.string().optional().describe('Article title (required if "id" is not provided)'),
+      id: z11.number().optional().describe('Page ID (required if "title" is not provided)')
     },
     {
       title: "Get article categories",
       readOnlyHint: true,
       destructiveHint: false
     },
-    async ({ title }) => handleGetArticleCategoriesTool(title)
+    async ({ title, id }) => handleGetArticleCategoriesTool(title, id)
   );
-  tool.update({ outputSchema: { title: z11.string(), categories: z11.array(z11.string()), count: z11.number() } });
+  tool.update({ outputSchema: { title: z11.union([z11.string(), z11.number()]), categories: z11.array(z11.string()), count: z11.number() } });
   return tool;
 }
-async function handleGetArticleCategoriesTool(title) {
+function getFirstItem2(obj) {
+  if (!obj) return null;
+  for (const key in obj) {
+    return obj[key];
+  }
+  return null;
+}
+async function handleGetArticleCategoriesTool(title, id) {
   try {
+    if (!title && id == null) {
+      return errorResult('Either "title" or "id" must be provided');
+    }
+    if (title && id != null) {
+      return errorResult('Provide either "title" or "id", not both');
+    }
     const bot = await getBot();
+    if (id !== void 0) {
+      const result = await new Promise((resolve, reject) => {
+        bot.api.call(
+          { action: "query", prop: "categories", pageids: id, cllimit: "max" },
+          (err, data) => {
+            if (err) reject(err);
+            else resolve(data);
+          },
+          "GET"
+        );
+      });
+      const pages = result.pages;
+      const page = getFirstItem2(pages);
+      if (!page || page.missing !== void 0) {
+        return errorResult(`Page with ID ${id} not found`);
+      }
+      const rawCategories = page.categories;
+      const categories2 = (rawCategories || []).map((c) => c.title);
+      return jsonResult({
+        title: page.title ?? id,
+        categories: categories2,
+        count: categories2.length
+      });
+    }
     const categories = await promisifyBotMethod(
       bot,
       "getArticleCategories",
@@ -787,21 +916,56 @@ function getArticlePropertiesTool(server) {
     "get-article-properties",
     "Get page properties (page_props table data) for a wiki article",
     {
-      title: z12.string().describe("Article title")
+      title: z12.string().optional().describe('Article title (required if "id" is not provided)'),
+      id: z12.number().optional().describe('Page ID (required if "title" is not provided)')
     },
     {
       title: "Get article properties",
       readOnlyHint: true,
       destructiveHint: false
     },
-    async ({ title }) => handleGetArticlePropertiesTool(title)
+    async ({ title, id }) => handleGetArticlePropertiesTool(title, id)
   );
-  tool.update({ outputSchema: { title: z12.string(), properties: z12.record(z12.unknown()) } });
+  tool.update({ outputSchema: { title: z12.union([z12.string(), z12.number()]), properties: z12.record(z12.unknown()) } });
   return tool;
 }
-async function handleGetArticlePropertiesTool(title) {
+function getFirstItem3(obj) {
+  if (!obj) return null;
+  for (const key in obj) {
+    return obj[key];
+  }
+  return null;
+}
+async function handleGetArticlePropertiesTool(title, id) {
   try {
+    if (!title && id == null) {
+      return errorResult('Either "title" or "id" must be provided');
+    }
+    if (title && id != null) {
+      return errorResult('Provide either "title" or "id", not both');
+    }
     const bot = await getBot();
+    if (id !== void 0) {
+      const result = await new Promise((resolve, reject) => {
+        bot.api.call(
+          { action: "query", prop: "pageprops", pageids: id },
+          (err, data) => {
+            if (err) reject(err);
+            else resolve(data);
+          },
+          "GET"
+        );
+      });
+      const pages = result.pages;
+      const page = getFirstItem3(pages);
+      if (!page || page.missing !== void 0) {
+        return errorResult(`Page with ID ${id} not found`);
+      }
+      return jsonResult({
+        title: page.title ?? id,
+        properties: page.pageprops || {}
+      });
+    }
     const properties = await promisifyBotMethod(
       bot,
       "getArticleProperties",
@@ -825,9 +989,12 @@ function getArticleInfoTool(server) {
     {
       title: z13.union([
         z13.string(),
+        z13.array(z13.string())
+      ]).optional().describe('Article title or array of titles (required if "id" is not provided)'),
+      id: z13.union([
         z13.number(),
-        z13.array(z13.union([z13.string(), z13.number()]))
-      ]).describe("Article title, page ID, or array of titles/IDs"),
+        z13.array(z13.number())
+      ]).optional().describe('Page ID or array of page IDs (required if "title" is not provided)'),
       properties: z13.array(z13.string()).optional().describe("Specific properties to retrieve (e.g. protection, talkid, url)")
     },
     {
@@ -835,24 +1002,58 @@ function getArticleInfoTool(server) {
       readOnlyHint: true,
       destructiveHint: false
     },
-    async ({ title, properties }) => handleGetArticleInfoTool(title, properties)
+    async ({ title, id, properties }) => handleGetArticleInfoTool(title, id, properties)
   );
-  tool.update({ outputSchema: { title: z13.string(), results: z13.array(z13.record(z13.unknown())), count: z13.number() } });
+  tool.update({ outputSchema: { identifier: z13.union([z13.string(), z13.number(), z13.array(z13.unknown())]), results: z13.array(z13.record(z13.unknown())), count: z13.number() } });
   return tool;
 }
-async function handleGetArticleInfoTool(title, properties) {
+async function handleGetArticleInfoTool(title, id, properties) {
   try {
+    const hasTitle = typeof title === "string" ? title.length > 0 : Array.isArray(title) ? title.length > 0 : false;
+    const hasId = typeof id === "number" ? id > 0 : Array.isArray(id) ? id.length > 0 : false;
+    if (!hasTitle && !hasId) {
+      return errorResult('Either "title" or "id" must be provided');
+    }
+    if (hasTitle && hasId) {
+      return errorResult('Provide either "title" or "id", not both');
+    }
     const bot = await getBot();
-    const options = properties ? { inprop: properties } : {};
+    if (hasId) {
+      const ids = Array.isArray(id) ? id : [id];
+      const pageids = ids.join("|");
+      const apiParams = {
+        action: "query",
+        prop: "info",
+        pageids,
+        inprop: properties?.join("|") || "protection|talkid|url"
+      };
+      const result = await new Promise((resolve, reject) => {
+        bot.api.call(
+          apiParams,
+          (err, data) => {
+            if (err) reject(err);
+            else resolve(data);
+          },
+          "GET"
+        );
+      });
+      const pages = result.pages;
+      const results2 = pages ? Object.values(pages).filter((p) => p.missing === void 0) : [];
+      return jsonResult({
+        identifier: Array.isArray(id) ? id : id,
+        results: results2,
+        count: results2.length
+      });
+    }
     const info = await promisifyBotMethod(
       bot,
       "getArticleInfo",
       title,
-      options
+      {}
     );
     const results = Array.isArray(info) ? info : [info];
     return jsonResult({
-      title,
+      identifier: title,
       results,
       count: results.length
     });
@@ -1212,7 +1413,8 @@ import { z as z22 } from "zod";
 function getLogTool(server) {
   const tool = server.tool(
     "get-log",
-    "Get log entries of a specific type (e.g. delete, block, move). Pagination: the response includes total (matching entries found) and displayed (returned in this batch). If displayed < total, more results exist \u2014 use the timestamp of the LAST returned entry as the start parameter for the next page." + {
+    "Get log entries of a specific type (e.g. delete, block, move). Pagination: the response includes total (matching entries found) and displayed (returned in this batch). If displayed < total, more results exist \u2014 use the timestamp of the LAST returned entry as the start parameter for the next page.",
+    {
       type: z22.string().describe("Log type (e.g. delete, block, move)"),
       start: z22.string().optional().describe(
         'Timestamp to start listing from \u2014 only return entries before this time. Accepts ISO 8601 (e.g. "2026-05-10T22:54:37Z"), MediaWiki format "YYYYMMDDHHMMSS", or unix timestamp. All times are UTC \u2014 MW ignores timezone offsets. To paginate: pass the timestamp of the LAST item from the previous page as start.'
@@ -1233,7 +1435,7 @@ async function handleGetLogTool(type, start, limit = 50) {
   try {
     const bot = await getBot();
     const entries = await new Promise((resolve, reject) => {
-      bot.getLog(type, start, (err, ...args) => {
+      bot.getLog(type, start || "", (err, ...args) => {
         if (err) {
           reject(err);
         } else {
@@ -1352,7 +1554,8 @@ import { z as z25 } from "zod";
 function getRecentChangesTool(server) {
   const tool = server.tool(
     "get-recent-changes",
-    "Get recent changes on the wiki. Pagination: the response includes total (matching changes found) and displayed (returned in this batch). If displayed < total, more results exist \u2014 use the timestamp of the LAST returned change as the start parameter for the next page." + {
+    "Get recent changes on the wiki. Pagination: the response includes total (matching changes found) and displayed (returned in this batch). If displayed < total, more results exist \u2014 use the timestamp of the LAST returned change as the start parameter for the next page.",
+    {
       start: z25.string().optional().describe(
         'Timestamp to start listing from \u2014 only return changes before this time. Accepts ISO 8601 (e.g. "2026-05-10T22:54:37Z"), MediaWiki format "YYYYMMDDHHMMSS", or unix timestamp. All times are UTC \u2014 MW ignores timezone offsets. To paginate: pass the timestamp of the LAST item from the previous page as start.'
       ),
@@ -1597,20 +1800,95 @@ async function handleGetBacklinksTool(title) {
   }
 }
 
-// src/tools/editing/edit.ts
+// src/tools/ro/get-article-by-revision.ts
 import { z as z32 } from "zod";
+function getArticleByRevisionTool(server) {
+  return server.tool(
+    "get-article-by-revision",
+    "Retrieve the content of a wiki article by a specific revision ID, without needing the page title or ID",
+    {
+      revision: z32.number().describe("Revision ID to fetch")
+    },
+    {
+      title: "Get article by revision",
+      readOnlyHint: true,
+      destructiveHint: false
+    },
+    async ({ revision }) => handleGetArticleByRevisionTool(revision)
+  );
+}
+async function handleGetArticleByRevisionTool(revision) {
+  try {
+    const bot = await getBot();
+    const result = await new Promise((resolve, reject) => {
+      bot.api.call(
+        {
+          action: "query",
+          prop: "revisions",
+          rvprop: "content",
+          revids: revision
+        },
+        (err, data) => {
+          if (err) reject(err);
+          else resolve(data);
+        },
+        "GET"
+      );
+    });
+    const pages = result.pages;
+    if (!pages) {
+      return {
+        content: [{ type: "text", text: `Revision ${revision} not found.` }],
+        isError: true
+      };
+    }
+    const pageIds = Object.keys(pages);
+    if (pageIds.length === 0) {
+      return {
+        content: [{ type: "text", text: `Revision ${revision} not found.` }],
+        isError: true
+      };
+    }
+    const page = pages[pageIds[0]];
+    if (!page || page.missing !== void 0) {
+      return {
+        content: [{ type: "text", text: `Revision ${revision} not found.` }],
+        isError: true
+      };
+    }
+    const revisions = page.revisions;
+    const rev = revisions?.[0];
+    if (!rev || rev["*"] == null) {
+      return {
+        content: [{ type: "text", text: `Revision ${revision} not found or has no content.` }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: rev["*"] }]
+    };
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error.message}` }],
+      isError: true
+    };
+  }
+}
+
+// src/tools/editing/edit.ts
+import { z as z33 } from "zod";
 function editTool(server) {
   const tool = server.tool(
     "edit",
     "Replace the ENTIRE content of a wiki page (requires authentication). CRITICAL: This is a FULL replacement \u2014 content you provide becomes the complete page, not an addition. There is NO undelete/undo tool \u2014 any damage you cause must be manually reverted by a human. To add a category or make a small change, you MUST first call get-article to retrieve the current content, modify it as needed, then pass the FULL modified content here. For appending or prepending without fetching the full page first, use the append/prepend tools instead.",
     {
-      title: z32.string().describe("Page title to edit"),
-      content: z32.string().describe("COMPLETE new wikitext for the ENTIRE page \u2014 not a snippet, not a prefix, not an appendage. This replaces everything. Always fetch the current content with get-article first, then modify and resubmit the full text."),
-      intent: z32.enum(["add", "revise", "delete"]).describe(
+      title: z33.string().describe("Page title to edit"),
+      content: z33.string().describe("COMPLETE new wikitext for the ENTIRE page \u2014 not a snippet, not a prefix, not an appendage. This replaces everything. Always fetch the current content with get-article first, then modify and resubmit the full text."),
+      intent: z33.enum(["add", "revise", "delete"]).describe(
         'Your editing intent: "add" = adding content (page should grow), "revise" = modifying content (small net change, must keep \u22653/4 of existing bytes), "delete" = removing significant content (page should shrink significantly)'
       ),
-      summary: z32.string().describe("Edit summary describing what was changed and why"),
-      minor: z32.boolean().optional().default(false).describe("Mark as minor edit")
+      summary: z33.string().describe("Edit summary describing what was changed and why"),
+      minor: z33.boolean().optional().default(false).describe("Mark as minor edit")
     },
     {
       title: "Edit page",
@@ -1619,7 +1897,7 @@ function editTool(server) {
     },
     async (params) => handleEditTool(params)
   );
-  tool.update({ outputSchema: { result: z32.string(), pageid: z32.number(), title: z32.string(), contentmodel: z32.string().optional(), newrevid: z32.number(), newtimestamp: z32.string().optional(), oldrevid: z32.number().optional() } });
+  tool.update({ outputSchema: { result: z33.string(), pageid: z33.number(), title: z33.string(), contentmodel: z33.string().optional(), newrevid: z33.number(), newtimestamp: z33.string().optional(), oldrevid: z33.number().optional() } });
   return tool;
 }
 async function handleEditTool(params) {
@@ -1673,15 +1951,15 @@ async function handleEditTool(params) {
 }
 
 // src/tools/editing/append.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 function appendTool(server) {
   const tool = server.tool(
     "append",
     "Append content to the END of a wiki page without changing existing content (requires authentication). Safe for adding categories, interwiki links, or any content that belongs at the bottom of a page.",
     {
-      title: z33.string().describe("Page title"),
-      content: z33.string().describe('Content to append to the end of the page (e.g., "\\n[[Category:MyCategory]]")'),
-      summary: z33.string().describe("Edit summary")
+      title: z34.string().describe("Page title"),
+      content: z34.string().describe('Content to append to the end of the page (e.g., "\\n[[Category:MyCategory]]")'),
+      summary: z34.string().describe("Edit summary")
     },
     {
       title: "Append to page",
@@ -1690,7 +1968,7 @@ function appendTool(server) {
     },
     async (params) => handleAppendTool(params)
   );
-  tool.update({ outputSchema: { success: z33.boolean(), title: z33.string() } });
+  tool.update({ outputSchema: { success: z34.boolean(), title: z34.string() } });
   return tool;
 }
 async function handleAppendTool(params) {
@@ -1712,15 +1990,15 @@ async function handleAppendTool(params) {
 }
 
 // src/tools/editing/prepend.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 function prependTool(server) {
   const tool = server.tool(
     "prepend",
     "Prepend content to the TOP of a wiki page without changing existing content (requires authentication). Useful for adding notices, templates, or cleanup tags that belong at the top of a page.",
     {
-      title: z34.string().describe("Page title to prepend to"),
-      content: z34.string().describe('Content to prepend to the top of the page (e.g., "{{Cleanup}}\\n")'),
-      summary: z34.string().describe("Edit summary")
+      title: z35.string().describe("Page title to prepend to"),
+      content: z35.string().describe('Content to prepend to the top of the page (e.g., "{{Cleanup}}\\n")'),
+      summary: z35.string().describe("Edit summary")
     },
     {
       title: "Prepend to page",
@@ -1729,7 +2007,7 @@ function prependTool(server) {
     },
     async (params) => handlePrependTool(params)
   );
-  tool.update({ outputSchema: { result: z34.string(), pageid: z34.number(), title: z34.string(), contentmodel: z34.string().optional(), newrevid: z34.number(), newtimestamp: z34.string().optional(), oldrevid: z34.number().optional() } });
+  tool.update({ outputSchema: { result: z35.string(), pageid: z35.number(), title: z35.string(), contentmodel: z35.string().optional(), newrevid: z35.number(), newtimestamp: z35.string().optional(), oldrevid: z35.number().optional() } });
   return tool;
 }
 async function handlePrependTool(params) {
@@ -1751,15 +2029,15 @@ async function handlePrependTool(params) {
 }
 
 // src/tools/editing/move.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 function moveTool(server) {
   const tool = server.tool(
     "move",
     "Move (rename) a wiki page \u2014 changes the page title and creates a redirect from the old name (requires authentication). The old page title becomes a redirect to the new title. All page history moves with the page.",
     {
-      from: z35.string().describe("Current/existing page title to rename"),
-      to: z35.string().describe("New target page title \u2014 must not already exist (unless moving to overwrite)"),
-      summary: z35.string().describe("Reason for the move (visible in move log)")
+      from: z36.string().describe("Current/existing page title to rename"),
+      to: z36.string().describe("New target page title \u2014 must not already exist (unless moving to overwrite)"),
+      summary: z36.string().describe("Reason for the move (visible in move log)")
     },
     {
       title: "Move page",
@@ -1768,7 +2046,7 @@ function moveTool(server) {
     },
     async (params) => handleMoveTool(params)
   );
-  tool.update({ outputSchema: { from: z35.string(), to: z35.string(), reason: z35.string(), redirectcreated: z35.boolean().optional() } });
+  tool.update({ outputSchema: { from: z36.string(), to: z36.string(), reason: z36.string(), redirectcreated: z36.boolean().optional() } });
   return tool;
 }
 async function handleMoveTool(params) {
@@ -1790,14 +2068,14 @@ async function handleMoveTool(params) {
 }
 
 // src/tools/editing/delete.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 function deleteTool(server) {
   const tool = server.tool(
     "delete",
     "PERMANENTLY delete a wiki page (requires authentication). CRITICAL: This action is IRREVERSIBLE \u2014 there is NO undelete/undo tool available. Any deletion must be manually restored by a human administrator. Only delete a page when the user explicitly asks for it. Always verify the title is correct before proceeding.",
     {
-      title: z36.string().describe("Exact page title to permanently delete \u2014 double-check this is correct"),
-      reason: z36.string().describe("Detailed reason for deletion (visible in deletion log)")
+      title: z37.string().describe("Exact page title to permanently delete \u2014 double-check this is correct"),
+      reason: z37.string().describe("Detailed reason for deletion (visible in deletion log)")
     },
     {
       title: "Delete page",
@@ -1806,7 +2084,7 @@ function deleteTool(server) {
     },
     async (params) => handleDeleteTool(params)
   );
-  tool.update({ outputSchema: { title: z36.string(), reason: z36.string(), logid: z36.number().optional() } });
+  tool.update({ outputSchema: { title: z37.string(), reason: z37.string(), logid: z37.number().optional() } });
   return tool;
 }
 async function handleDeleteTool(params) {
@@ -1827,24 +2105,24 @@ async function handleDeleteTool(params) {
 }
 
 // src/tools/editing/protect.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 function protectTool(server) {
   const tool = server.tool(
     "protect",
     'Protect or unprotect a wiki page to restrict editing/moving (requires authentication). CRITICAL: Protection can lock out legitimate editors \u2014 only protect pages when there is a clear need (ongoing vandalism, edit war, high-risk template, policy page). To remove protection, set level to "all". Available levels: "all" (anyone), "autoconfirmed" (trusted users), "sysop" (admins only).',
     {
-      title: z37.string().describe("Page title to protect or unprotect"),
-      protections: z37.array(
-        z37.object({
-          type: z37.enum(["edit", "move"]).describe('Action to restrict: "edit" or "move"'),
-          level: z37.enum(["all", "autoconfirmed", "sysop"]).optional().default("all").describe(
+      title: z38.string().describe("Page title to protect or unprotect"),
+      protections: z38.array(
+        z38.object({
+          type: z38.enum(["edit", "move"]).describe('Action to restrict: "edit" or "move"'),
+          level: z38.enum(["all", "autoconfirmed", "sysop"]).optional().default("all").describe(
             'Who can perform this action: "all" = no restriction, "autoconfirmed" = trusted users only, "sysop" = admins only'
           ),
-          expiry: z37.string().optional().describe('How long protection lasts (e.g. "1 day", "1 week", "infinite"). Default is indefinite.')
+          expiry: z38.string().optional().describe('How long protection lasts (e.g. "1 day", "1 week", "infinite"). Default is indefinite.')
         })
       ).describe('Protection rules \u2014 typically one entry for "edit" and optionally one for "move". Example: [{type:"edit",level:"sysop",expiry:"1 week"}]'),
-      reason: z37.string().optional().describe("Reason for changing protection, visible in the page log"),
-      cascade: z37.boolean().optional().default(false).describe("If true, transcluded templates/pages inherit this protection. Only works with full sysop protection on edit. Use with caution.")
+      reason: z38.string().optional().describe("Reason for changing protection, visible in the page log"),
+      cascade: z38.boolean().optional().default(false).describe("If true, transcluded templates/pages inherit this protection. Only works with full sysop protection on edit. Use with caution.")
     },
     {
       title: "Protect page",
@@ -1853,7 +2131,7 @@ function protectTool(server) {
     },
     async (params) => handleProtectTool(params)
   );
-  tool.update({ outputSchema: { title: z37.string(), reason: z37.string().optional(), protections: z37.array(z37.record(z37.unknown())), cascade: z37.boolean().optional() } });
+  tool.update({ outputSchema: { title: z38.string(), reason: z38.string().optional(), protections: z38.array(z38.record(z38.unknown())), cascade: z38.boolean().optional() } });
   return tool;
 }
 async function handleProtectTool(params) {
@@ -1881,13 +2159,13 @@ async function handleProtectTool(params) {
 }
 
 // src/tools/editing/purge.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 function purgeTool(server) {
   const tool = server.tool(
     "purge",
     "Purge the server-side cache for one or more wiki pages (requires authentication). Forces MediaWiki to regenerate the page from current wikitext. This is a safe, non-destructive action.",
     {
-      titles: z38.union([z38.string(), z38.array(z38.string())]).describe("Page title(s) or category name to purge")
+      titles: z39.union([z39.string(), z39.array(z39.string())]).describe("Page title(s) or category name to purge")
     },
     {
       title: "Purge pages",
@@ -1896,7 +2174,7 @@ function purgeTool(server) {
     },
     async (params) => handlePurgeTool(params)
   );
-  tool.update({ outputSchema: { pages: z38.array(z38.record(z38.unknown())) } });
+  tool.update({ outputSchema: { pages: z39.array(z39.record(z39.unknown())) } });
   return tool;
 }
 async function handlePurgeTool(params) {
@@ -1914,15 +2192,15 @@ async function handlePurgeTool(params) {
 }
 
 // src/tools/editing/send-email.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function sendEmailTool(server) {
   const tool = server.tool(
     "send-email",
     "Send an ACTUAL email to a wiki user via the wiki's built-in email system (requires authentication). CRITICAL: This sends a real email to the user's registered address \u2014 it is NOT a simulation. The recipient will see it came from the authenticated bot operator's wiki account. Abuse (spam, harassment, unsolicited messages) WILL result in the bot account being blocked. ONLY use this when the human user has explicitly asked you to send an email.",
     {
-      username: z39.string().describe("Target wiki username \u2014 email goes to their registered email address"),
-      subject: z39.string().describe("Email subject line \u2014 be clear and professional, no misleading subjects"),
-      text: z39.string().describe("Plain text email body \u2014 will be delivered as-is to the recipient's inbox")
+      username: z40.string().describe("Target wiki username \u2014 email goes to their registered email address"),
+      subject: z40.string().describe("Email subject line \u2014 be clear and professional, no misleading subjects"),
+      text: z40.string().describe("Plain text email body \u2014 will be delivered as-is to the recipient's inbox")
     },
     {
       title: "Send email",
@@ -1931,7 +2209,7 @@ function sendEmailTool(server) {
     },
     async (params) => handleSendEmailTool(params)
   );
-  tool.update({ outputSchema: { result: z39.string(), message: z39.string().optional() } });
+  tool.update({ outputSchema: { result: z40.string(), message: z40.string().optional() } });
   return tool;
 }
 async function handleSendEmailTool(params) {
@@ -1951,15 +2229,15 @@ async function handleSendEmailTool(params) {
 }
 
 // src/tools/editing/upload.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 function uploadTool(server) {
   const tool = server.tool(
     "upload",
     "Upload a file to the wiki (requires authentication). CRITICAL: If a file with the same name already exists, it WILL BE OVERWRITTEN. Ensure you have the right to upload the content. Use only when explicitly requested.",
     {
-      filename: z40.string().describe('Destination filename on wiki (e.g., "MyImage.png") \u2014 existing file will be overwritten!'),
-      content: z40.string().describe("File content encoded as base64 string"),
-      comment: z40.string().optional().describe("Upload comment describing the file")
+      filename: z41.string().describe('Destination filename on wiki (e.g., "MyImage.png") \u2014 existing file will be overwritten!'),
+      content: z41.string().describe("File content encoded as base64 string"),
+      comment: z41.string().optional().describe("Upload comment describing the file")
     },
     {
       title: "Upload file",
@@ -1968,7 +2246,7 @@ function uploadTool(server) {
     },
     async (params) => handleUploadTool(params)
   );
-  tool.update({ outputSchema: { result: z40.string(), filename: z40.string(), imageinfo: z40.record(z40.unknown()).optional() } });
+  tool.update({ outputSchema: { result: z41.string(), filename: z41.string(), imageinfo: z41.record(z41.unknown()).optional() } });
   return tool;
 }
 async function handleUploadTool(params) {
@@ -1990,15 +2268,15 @@ async function handleUploadTool(params) {
 }
 
 // src/tools/editing/upload-by-url.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 function uploadByUrlTool(server) {
   const tool = server.tool(
     "upload-by-url",
     "Upload a file to the wiki by downloading it from a URL (requires authentication). CRITICAL: If a file with the same name already exists, it WILL BE OVERWRITTEN. Ensure you have the right to upload the content from the source URL.",
     {
-      filename: z41.string().describe('Destination filename on wiki (e.g., "Diagram.png") \u2014 existing file will be overwritten!'),
-      url: z41.string().url().describe("Source URL to download the file from \u2014 must be publicly accessible"),
-      summary: z41.string().optional().describe("Upload summary")
+      filename: z42.string().describe('Destination filename on wiki (e.g., "Diagram.png") \u2014 existing file will be overwritten!'),
+      url: z42.string().url().describe("Source URL to download the file from \u2014 must be publicly accessible"),
+      summary: z42.string().optional().describe("Upload summary")
     },
     {
       title: "Upload file by URL",
@@ -2007,7 +2285,7 @@ function uploadByUrlTool(server) {
     },
     async (params) => handleUploadByUrlTool(params)
   );
-  tool.update({ outputSchema: { result: z41.string(), filename: z41.string(), imageinfo: z41.record(z41.unknown()).optional() } });
+  tool.update({ outputSchema: { result: z42.string(), filename: z42.string(), imageinfo: z42.record(z42.unknown()).optional() } });
   return tool;
 }
 async function handleUploadByUrlTool(params) {
@@ -2028,15 +2306,15 @@ async function handleUploadByUrlTool(params) {
 }
 
 // src/tools/editing/add-flow-topic.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 function addFlowTopicTool(server) {
   const tool = server.tool(
     "add-flow-topic",
     "Add a new Flow/Structured Discussions topic to a wiki talk page (requires authentication). Creates a publicly visible discussion thread on the wiki. Ensure the content is appropriate and relevant.",
     {
-      title: z42.string().describe('Talk page title to add the topic to (e.g., "Talk:Main Page")'),
-      subject: z42.string().describe("Topic title/heading \u2014 should summarize the discussion topic"),
-      content: z42.string().describe("Topic body content in wikitext format")
+      title: z43.string().describe('Talk page title to add the topic to (e.g., "Talk:Main Page")'),
+      subject: z43.string().describe("Topic title/heading \u2014 should summarize the discussion topic"),
+      content: z43.string().describe("Topic body content in wikitext format")
     },
     {
       title: "Add Flow topic",
@@ -2045,7 +2323,7 @@ function addFlowTopicTool(server) {
     },
     async (params) => handleAddFlowTopicTool(params)
   );
-  tool.update({ outputSchema: { "new-topic": z42.record(z42.unknown()) } });
+  tool.update({ outputSchema: { "new-topic": z43.record(z43.unknown()) } });
   return tool;
 }
 async function handleAddFlowTopicTool(params) {
@@ -2065,14 +2343,14 @@ async function handleAddFlowTopicTool(params) {
 }
 
 // src/tools/editing/create-account.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 function createAccountTool(server) {
   const tool = server.tool(
     "create-account",
     "Create a NEW user account on the wiki (requires authentication). CRITICAL: This creates a real user account. Do NOT create accounts for yourself or without explicit user request. The account will be permanently registered on the wiki.",
     {
-      username: z43.string().describe("Desired username for the new account \u2014 must follow wiki username rules"),
-      password: z43.string().describe("Password for the new account \u2014 use a strong, unique password")
+      username: z44.string().describe("Desired username for the new account \u2014 must follow wiki username rules"),
+      password: z44.string().describe("Password for the new account \u2014 use a strong, unique password")
     },
     {
       title: "Create user account",
@@ -2081,7 +2359,7 @@ function createAccountTool(server) {
     },
     async (params) => handleCreateAccountTool(params)
   );
-  tool.update({ outputSchema: { account: z43.record(z43.unknown()) } });
+  tool.update({ outputSchema: { account: z44.record(z44.unknown()) } });
   return tool;
 }
 async function handleCreateAccountTool(params) {
@@ -2131,7 +2409,8 @@ var readToolRegistrars = [
   getMediaWikiVersionTool,
   getQueryPageTool,
   getExternalLinksTool,
-  getBacklinksTool
+  getBacklinksTool,
+  getArticleByRevisionTool
 ];
 var writeToolRegistrars = [
   editTool,

package/package.json

@@ -1,47 +1,55 @@
-{
-  "name": "@xiedada/nodemw-mcp-server",
-  "version": "0.1.0",
-  "description": "MCP server for nodemw - MediaWiki API client",
-  "type": "module",
-  "main": "dist/index.js",
-  "bin": {
-    "nodemw-mcp-server": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "node scripts/build.js",
-    "dev": "node scripts/build.js --watch",
-    "lint": "eslint src/**/*.ts",
-    "test": "vitest",
-    "prepare": "npm run build",
-    "clean": "rimraf dist"
-  },
-  "keywords": [
-    "mcp",
-    "mediawiki",
-    "nodemw",
-    "wiki"
-  ],
-  "author": "",
-  "license": "BSD-2-Clause",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "nodemw": "^0.26.0",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
-    "esbuild": "^0.24.0",
-    "eslint": "^9.0.0",
-    "rimraf": "^5.0.5",
-    "typescript": "^5.5.0",
-    "vitest": "^2.0.0"
-  },
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}
+{
+  "name": "@xiedada/nodemw-mcp-server",
+  "version": "0.1.2",
+  "description": "MCP server for nodemw - MediaWiki API client",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TimXiedada/nodemw-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/TimXiedada/nodemw-mcp/issues"
+  },
+  "homepage": "https://github.com/TimXiedada/nodemw-mcp#readme",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "nodemw-mcp-server": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "node scripts/build.js",
+    "dev": "node scripts/build.js --watch",
+    "lint": "eslint src/**/*.ts",
+    "test": "vitest",
+    "prepare": "npm run build",
+    "clean": "rimraf dist"
+  },
+  "keywords": [
+    "mcp",
+    "mediawiki",
+    "nodemw",
+    "wiki"
+  ],
+  "author": "",
+  "license": "BSD-2-Clause",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "nodemw": "^0.26.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "esbuild": "^0.24.0",
+    "eslint": "^9.0.0",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}