@pschroee/redmine-mcp 0.3.1

package/dist/tools/core.js

@@ -0,0 +1,242 @@
+import { z } from "zod";
+export function registerCoreTools(server, client) {
+    // === ISSUES ===
+    server.registerTool("list_issues", {
+        description: "List issues from Redmine with optional filters and sorting",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).optional().describe("Filter by project ID or identifier"),
+            tracker_id: z.number().optional().describe("Filter by tracker ID"),
+            status_id: z.union([z.string(), z.number()]).optional().describe("Filter by status: 'open', 'closed', '*', or status ID"),
+            assigned_to_id: z.union([z.number(), z.string()]).optional().describe("Filter by assigned user ID or 'me'"),
+            author_id: z.union([z.number(), z.string()]).optional().describe("Filter by author user ID or 'me'"),
+            category_id: z.number().optional().describe("Filter by category ID"),
+            fixed_version_id: z.number().optional().describe("Filter by version ID"),
+            parent_id: z.number().optional().describe("Filter by parent issue ID"),
+            subject: z.string().optional().describe("Filter by subject (use ~ for contains)"),
+            created_on: z.string().optional().describe("Filter by created date (e.g., '>=2023-01-01', '><2023-01-01|2023-12-31')"),
+            updated_on: z.string().optional().describe("Filter by updated date"),
+            sort: z.string().optional().describe("Sort by field:direction (e.g., 'updated_on:desc,priority:asc')"),
+            include: z.string().optional().describe("Include associated data: attachments, relations, journals, watchers, children"),
+            limit: z.number().optional().describe("Maximum results (default 25, max 100)"),
+            offset: z.number().optional().describe("Skip first N results"),
+        },
+    }, async (params) => {
+        const result = await client.listIssues(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_issue", {
+        description: "Get details of a specific issue by ID",
+        inputSchema: {
+            issue_id: z.number().describe("The issue ID"),
+            include: z.string().optional().describe("Include: attachments, relations, journals, watchers, children, changesets, allowed_statuses"),
+        },
+    }, async (params) => {
+        const result = await client.getIssue(params.issue_id, params.include);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_issue", {
+        description: "Create a new issue in Redmine",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            subject: z.string().describe("Issue subject/title"),
+            description: z.string().optional().describe("Issue description (supports Textile/Markdown)"),
+            tracker_id: z.number().optional().describe("Tracker ID (e.g., Bug, Feature)"),
+            status_id: z.number().optional().describe("Status ID"),
+            priority_id: z.number().optional().describe("Priority ID"),
+            assigned_to_id: z.number().optional().describe("User ID to assign"),
+            category_id: z.number().optional().describe("Category ID"),
+            fixed_version_id: z.number().optional().describe("Target version ID"),
+            parent_issue_id: z.number().optional().describe("Parent issue ID for subtasks"),
+            custom_fields: z.array(z.object({
+                id: z.number(),
+                value: z.union([z.string(), z.array(z.string())]),
+            })).optional().describe("Custom field values"),
+            watcher_user_ids: z.array(z.number()).optional().describe("User IDs to add as watchers"),
+            is_private: z.boolean().optional().describe("Make issue private"),
+            estimated_hours: z.number().optional().describe("Estimated hours"),
+            start_date: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+            due_date: z.string().optional().describe("Due date (YYYY-MM-DD)"),
+        },
+    }, async (params) => {
+        const result = await client.createIssue(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_issue", {
+        description: "Update an existing issue",
+        inputSchema: {
+            issue_id: z.number().describe("The issue ID to update"),
+            subject: z.string().optional().describe("New subject/title"),
+            description: z.string().optional().describe("New description"),
+            project_id: z.union([z.string(), z.number()]).optional().describe("Move to different project"),
+            tracker_id: z.number().optional().describe("Change tracker"),
+            status_id: z.number().optional().describe("Change status"),
+            priority_id: z.number().optional().describe("Change priority"),
+            assigned_to_id: z.union([z.number(), z.string()]).optional().describe("Change assignee (ID or '' to unassign)"),
+            category_id: z.number().optional().describe("Change category"),
+            fixed_version_id: z.union([z.number(), z.string()]).optional().describe("Change target version (ID or '' to clear)"),
+            parent_issue_id: z.union([z.number(), z.string()]).optional().describe("Change parent (ID or '' to clear)"),
+            custom_fields: z.array(z.object({
+                id: z.number(),
+                value: z.union([z.string(), z.array(z.string())]),
+            })).optional().describe("Update custom fields"),
+            notes: z.string().optional().describe("Add a comment/note to the issue"),
+            private_notes: z.boolean().optional().describe("Make the note private"),
+            is_private: z.boolean().optional().describe("Change private flag"),
+            estimated_hours: z.number().optional().describe("Update estimated hours"),
+            done_ratio: z.number().optional().describe("Update % done (0-100). Note: For parent issues with children, this may be calculated automatically depending on Redmine configuration"),
+            start_date: z.string().optional().describe("Update start date"),
+            due_date: z.string().optional().describe("Update due date"),
+        },
+    }, async (params) => {
+        const { issue_id, ...data } = params;
+        const result = await client.updateIssue(issue_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("delete_issue", {
+        description: "Delete an issue permanently",
+        inputSchema: {
+            issue_id: z.number().describe("The issue ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteIssue(params.issue_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("add_issue_watcher", {
+        description: "Add a user as watcher to an issue",
+        inputSchema: {
+            issue_id: z.number().describe("The issue ID"),
+            user_id: z.number().describe("The user ID to add as watcher"),
+        },
+    }, async (params) => {
+        const result = await client.addIssueWatcher(params.issue_id, params.user_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("remove_issue_watcher", {
+        description: "Remove a user from issue watchers",
+        inputSchema: {
+            issue_id: z.number().describe("The issue ID"),
+            user_id: z.number().describe("The user ID to remove from watchers"),
+        },
+    }, async (params) => {
+        const result = await client.removeIssueWatcher(params.issue_id, params.user_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    // === PROJECTS ===
+    server.registerTool("list_projects", {
+        description: "List all accessible projects from Redmine",
+        inputSchema: {
+            include: z.string().optional().describe("Include: trackers, issue_categories, enabled_modules, time_entry_activities, issue_custom_fields"),
+            limit: z.number().optional().describe("Maximum results (default 25, max 100)"),
+            offset: z.number().optional().describe("Skip first N results"),
+        },
+    }, async (params) => {
+        const result = await client.listProjects(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_project", {
+        description: "Get details of a specific project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            include: z.string().optional().describe("Include: trackers, issue_categories, enabled_modules, time_entry_activities, issue_custom_fields"),
+        },
+    }, async (params) => {
+        const result = await client.getProject(params.project_id, params.include);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_project", {
+        description: "Create a new project in Redmine",
+        inputSchema: {
+            name: z.string().describe("Project name"),
+            identifier: z.string().describe("Unique identifier (lowercase, no spaces, used in URLs)"),
+            description: z.string().optional().describe("Project description"),
+            homepage: z.string().optional().describe("Project homepage URL"),
+            is_public: z.boolean().optional().describe("Whether project is public (default true)"),
+            parent_id: z.union([z.string(), z.number()]).optional().describe("Parent project ID or identifier"),
+            inherit_members: z.boolean().optional().describe("Inherit members from parent project"),
+            default_assigned_to_id: z.number().optional().describe("Default assignee user ID"),
+            default_version_id: z.number().optional().describe("Default version ID"),
+            tracker_ids: z.array(z.number()).optional().describe("Enabled tracker IDs"),
+            enabled_module_names: z.array(z.string()).optional().describe("Enabled module names"),
+            issue_custom_field_ids: z.array(z.number()).optional().describe("Enabled custom field IDs"),
+        },
+    }, async (params) => {
+        const result = await client.createProject(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_project", {
+        description: "Update an existing project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            name: z.string().optional().describe("New project name"),
+            description: z.string().optional().describe("New description"),
+            homepage: z.string().optional().describe("New homepage URL"),
+            is_public: z.boolean().optional().describe("Change public visibility"),
+            parent_id: z.union([z.string(), z.number()]).optional().describe("Change parent project"),
+            inherit_members: z.boolean().optional().describe("Change inherit members"),
+            default_assigned_to_id: z.number().optional().describe("Change default assignee"),
+            default_version_id: z.number().optional().describe("Change default version"),
+            tracker_ids: z.array(z.number()).optional().describe("Update enabled trackers"),
+            enabled_module_names: z.array(z.string()).optional().describe("Update enabled modules"),
+            issue_custom_field_ids: z.array(z.number()).optional().describe("Update enabled custom fields"),
+        },
+    }, async (params) => {
+        const { project_id, ...data } = params;
+        const result = await client.updateProject(project_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("delete_project", {
+        description: "Delete a project permanently (requires admin privileges)",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteProject(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("archive_project", {
+        description: "Archive a project (Redmine 5.0+)",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier to archive"),
+        },
+    }, async (params) => {
+        const result = await client.archiveProject(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("unarchive_project", {
+        description: "Unarchive a project (Redmine 5.0+)",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier to unarchive"),
+        },
+    }, async (params) => {
+        const result = await client.unarchiveProject(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+}

package/dist/tools/enumerations.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerEnumerationsTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/enumerations.js

@@ -0,0 +1,26 @@
+export function registerEnumerationsTools(server, client) {
+    server.registerTool("list_issue_priorities", {
+        description: "List all issue priorities with their IDs (Low, Normal, High, Urgent, Immediate)",
+    }, async () => {
+        const result = await client.listIssuePriorities();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("list_time_entry_activities", {
+        description: "List all time entry activities with their IDs (Design, Development, etc.)",
+    }, async () => {
+        const result = await client.listTimeEntryActivities();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("list_document_categories", {
+        description: "List all document categories with their IDs",
+    }, async () => {
+        const result = await client.listDocumentCategories();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/files.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerFilesTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/files.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { readFile } from "fs/promises";
+export function registerFilesTools(server, client) {
+    // === ATTACHMENTS ===
+    server.registerTool("get_attachment", {
+        description: "Get metadata of a specific attachment",
+        inputSchema: {
+            attachment_id: z.number().describe("The attachment ID"),
+        },
+    }, async (params) => {
+        const result = await client.getAttachment(params.attachment_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("delete_attachment", {
+        description: "Delete an attachment",
+        inputSchema: {
+            attachment_id: z.number().describe("The attachment ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteAttachment(params.attachment_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("upload_file", {
+        description: "Upload a file to Redmine (returns token for attaching to issues/wiki)",
+        inputSchema: {
+            file_path: z.string().describe("Local file path to upload"),
+            filename: z.string().describe("Filename to use in Redmine"),
+            content_type: z.string().optional().describe("MIME type (auto-detected if not provided)"),
+        },
+    }, async (params) => {
+        const content = await readFile(params.file_path);
+        const contentType = params.content_type || "application/octet-stream";
+        const result = await client.uploadFile(params.filename, contentType, content);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // === PROJECT FILES ===
+    server.registerTool("list_project_files", {
+        description: "List all files attached to a project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+        },
+    }, async (params) => {
+        const result = await client.listProjectFiles(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("upload_project_file", {
+        description: "Attach an uploaded file to a project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            token: z.string().describe("Upload token from upload_file"),
+            version_id: z.number().optional().describe("Associated version ID"),
+            filename: z.string().optional().describe("Override filename"),
+            description: z.string().optional().describe("File description"),
+        },
+    }, async (params) => {
+        const { project_id, ...data } = params;
+        const result = await client.uploadProjectFile(project_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export type ToolRegistrationFn = (server: McpServer, client: RedmineClient) => void;
+export declare const toolGroups: Record<string, ToolRegistrationFn>;
+export type ToolGroup = keyof typeof toolGroups;
+export declare const ALL_GROUPS: ToolGroup[];
+export declare function isValidToolGroup(group: string): group is ToolGroup;
+export declare function validateToolGroups(groups: string[]): ToolGroup[];
+export declare function resolveGroups(include?: string[], exclude?: string[]): ToolGroup[];
+export declare function registerTools(server: McpServer, client: RedmineClient, groups: ToolGroup[]): void;

package/dist/tools/index.js

@@ -0,0 +1,59 @@
+import { registerAccountTools } from "./account.js";
+import { registerAdminTools } from "./admin.js";
+import { registerCoreTools } from "./core.js";
+import { registerEnumerationsTools } from "./enumerations.js";
+import { registerFilesTools } from "./files.js";
+import { registerMembershipsTools } from "./memberships.js";
+import { registerMetadataTools } from "./metadata.js";
+import { registerRelationsTools } from "./relations.js";
+import { registerRolesTools } from "./roles.js";
+import { registerSearchTools } from "./search.js";
+import { registerTimeTools } from "./time.js";
+import { registerWikiTools } from "./wiki.js";
+export const toolGroups = {
+    core: registerCoreTools,
+    metadata: registerMetadataTools,
+    wiki: registerWikiTools,
+    files: registerFilesTools,
+    relations: registerRelationsTools,
+    search: registerSearchTools,
+    account: registerAccountTools,
+    time: registerTimeTools,
+    enumerations: registerEnumerationsTools,
+    memberships: registerMembershipsTools,
+    roles: registerRolesTools,
+    admin: registerAdminTools,
+};
+export const ALL_GROUPS = Object.keys(toolGroups);
+export function isValidToolGroup(group) {
+    return group in toolGroups;
+}
+export function validateToolGroups(groups) {
+    const invalid = groups.filter((g) => !isValidToolGroup(g));
+    if (invalid.length > 0) {
+        throw new Error(`Invalid tool group(s): ${invalid.join(", ")}. Valid groups: ${ALL_GROUPS.join(", ")}`);
+    }
+    return groups;
+}
+export function resolveGroups(include, exclude) {
+    let groups;
+    if (include && include.length > 0) {
+        groups = validateToolGroups(include);
+    }
+    else {
+        groups = [...ALL_GROUPS];
+    }
+    if (exclude && exclude.length > 0) {
+        const excludeSet = new Set(validateToolGroups(exclude));
+        groups = groups.filter((g) => !excludeSet.has(g));
+    }
+    if (groups.length === 0) {
+        throw new Error("No tool groups selected. At least one group must be enabled.");
+    }
+    return groups;
+}
+export function registerTools(server, client, groups) {
+    for (const group of groups) {
+        toolGroups[group](server, client);
+    }
+}

package/dist/tools/issues.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerIssueTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/issues.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+export function registerIssueTools(server, client) {
+    server.tool("list_issues", "List issues from Redmine with optional filters", {
+        project_id: z
+            .union([z.string(), z.number()])
+            .optional()
+            .describe("Filter by project ID or identifier"),
+        status_id: z
+            .string()
+            .optional()
+            .describe("Filter by status: open, closed, or status ID"),
+        assigned_to_id: z
+            .number()
+            .optional()
+            .describe("Filter by assigned user ID"),
+        limit: z.number().optional().describe("Maximum results (default 25, max 100)"),
+        offset: z.number().optional().describe("Skip first N results"),
+    }, async (params) => {
+        const result = await client.listIssues(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("get_issue", "Get details of a specific issue by ID", {
+        issue_id: z.number().describe("The issue ID"),
+    }, async (params) => {
+        const result = await client.getIssue(params.issue_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("create_issue", "Create a new issue in Redmine", {
+        project_id: z
+            .union([z.string(), z.number()])
+            .describe("Project ID or identifier"),
+        subject: z.string().describe("Issue subject/title"),
+        description: z.string().optional().describe("Issue description"),
+        tracker_id: z.number().optional().describe("Tracker ID (e.g., Bug, Feature)"),
+        priority_id: z.number().optional().describe("Priority ID"),
+        assigned_to_id: z.number().optional().describe("User ID to assign"),
+    }, async (params) => {
+        const result = await client.createIssue(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("update_issue", "Update an existing issue", {
+        issue_id: z.number().describe("The issue ID to update"),
+        subject: z.string().optional().describe("New subject/title"),
+        description: z.string().optional().describe("New description"),
+        status_id: z.number().optional().describe("New status ID"),
+        assigned_to_id: z.number().optional().describe("New assignee user ID"),
+        notes: z.string().optional().describe("Add a comment/note to the issue"),
+    }, async (params) => {
+        const { issue_id, ...data } = params;
+        const result = await client.updateIssue(issue_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/memberships.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerMembershipsTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/memberships.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export function registerMembershipsTools(server, client) {
+    server.registerTool("list_project_memberships", {
+        description: "List all memberships (users and groups) for a project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            limit: z.number().optional().describe("Maximum results"),
+            offset: z.number().optional().describe("Skip first N results"),
+        },
+    }, async (params) => {
+        const { project_id, ...rest } = params;
+        const result = await client.listProjectMemberships(project_id, rest);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_membership", {
+        description: "Get details of a specific membership",
+        inputSchema: {
+            membership_id: z.number().describe("Membership ID"),
+        },
+    }, async (params) => {
+        const result = await client.getMembership(params.membership_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_project_membership", {
+        description: "Add a user or group to a project with specified roles",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            user_id: z.number().describe("User ID or Group ID to add"),
+            role_ids: z.array(z.number()).describe("Role IDs to assign (use list_roles to get IDs)"),
+        },
+    }, async (params) => {
+        const { project_id, ...data } = params;
+        const result = await client.createProjectMembership(project_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_membership", {
+        description: "Update roles for a membership (cannot change user/project)",
+        inputSchema: {
+            membership_id: z.number().describe("Membership ID to update"),
+            role_ids: z.array(z.number()).describe("New role IDs"),
+        },
+    }, async (params) => {
+        const { membership_id, ...data } = params;
+        const result = await client.updateMembership(membership_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("delete_membership", {
+        description: "Remove a user or group from a project",
+        inputSchema: {
+            membership_id: z.number().describe("Membership ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteMembership(params.membership_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+}

package/dist/tools/metadata.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerMetadataTools(server: McpServer, client: RedmineClient): void;