@pschroee/redmine-mcp 0.4.5 → 0.5.1

package/dist/formatters/user.js

@@ -0,0 +1,83 @@
+import { formatDate } from "./utils.js";
+const USER_STATUS = {
+    1: "Active",
+    2: "Registered",
+    3: "Locked",
+};
+/**
+ * Format a single user as complete Markdown
+ */
+export function formatUser(response) {
+    const user = response.user;
+    const lines = [];
+    // Header
+    lines.push(`# ${user.firstname} ${user.lastname}`);
+    lines.push("");
+    // Status line
+    const statusParts = [];
+    statusParts.push(`**Login:** ${user.login}`);
+    const status = user.status !== undefined ? USER_STATUS[user.status] || "Unknown" : "Unknown";
+    statusParts.push(`**Status:** ${status}`);
+    if (user.admin) {
+        statusParts.push(`**Role:** Admin`);
+    }
+    lines.push(statusParts.join(" | "));
+    lines.push("");
+    // Metadata table
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    if (user.mail) {
+        lines.push(`| Email | ${user.mail} |`);
+    }
+    lines.push(`| Created | ${formatDate(user.created_on)} |`);
+    if (user.last_login_on) {
+        lines.push(`| Last Login | ${formatDate(user.last_login_on)} |`);
+    }
+    lines.push("");
+    // Groups
+    if (user.groups && user.groups.length > 0) {
+        lines.push("## Groups");
+        lines.push("");
+        for (const group of user.groups) {
+            lines.push(`- ${group.name}`);
+        }
+        lines.push("");
+    }
+    // Project Memberships
+    if (user.memberships && user.memberships.length > 0) {
+        lines.push("## Project Memberships");
+        lines.push("");
+        for (const membership of user.memberships) {
+            const roles = membership.roles.map((r) => r.name).join(", ");
+            lines.push(`- **${membership.project.name}:** ${roles}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}
+/**
+ * Format a list of users as Markdown table
+ */
+export function formatUserList(response) {
+    const lines = [];
+    // Header
+    lines.push(`# Users (${response.total_count})`);
+    lines.push("");
+    // Empty case
+    if (response.users.length === 0) {
+        lines.push("No users found.");
+        return lines.join("\n");
+    }
+    // Table header
+    lines.push("| Name | Login | Email | Status | Role |");
+    lines.push("|------|-------|-------|--------|------|");
+    // Table rows
+    for (const user of response.users) {
+        const name = `${user.firstname} ${user.lastname}`;
+        const email = user.mail || "";
+        const status = user.status !== undefined ? USER_STATUS[user.status] || "Unknown" : "Unknown";
+        const role = user.admin ? "Admin" : "User";
+        lines.push(`| ${name} | ${user.login} | ${email} | ${status} | ${role} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Format an ISO date string to readable local datetime format (YYYY-MM-DD HH:mm)
+ */
+export declare function formatDate(isoDate: string): string;
+/**
+ * Format an ISO date string to short date format (YYYY-MM-DD)
+ */
+export declare function formatDateShort(isoDate: string): string;
+/**
+ * Truncate text to a maximum length with ellipsis
+ */
+export declare function truncate(text: string, maxLength: number): string;

package/dist/formatters/utils.js

@@ -0,0 +1,31 @@
+/**
+ * Format an ISO date string to readable local datetime format (YYYY-MM-DD HH:mm)
+ */
+export function formatDate(isoDate) {
+    const date = new Date(isoDate);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+/**
+ * Format an ISO date string to short date format (YYYY-MM-DD)
+ */
+export function formatDateShort(isoDate) {
+    const date = new Date(isoDate);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+/**
+ * Truncate text to a maximum length with ellipsis
+ */
+export function truncate(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.slice(0, maxLength) + "...";
+}

package/dist/formatters/version.d.ts

@@ -0,0 +1,11 @@
+import type { RedmineVersion, RedmineVersionsResponse } from "../redmine/types.js";
+/**
+ * Format a single version as complete Markdown
+ */
+export declare function formatVersion(response: {
+    version: RedmineVersion;
+}): string;
+/**
+ * Format a list of versions as Markdown table
+ */
+export declare function formatVersionList(response: RedmineVersionsResponse): string;

package/dist/formatters/version.js

@@ -0,0 +1,75 @@
+const STATUS_BADGE = {
+    open: "Open",
+    locked: "Locked",
+    closed: "Closed",
+};
+/**
+ * Format a status badge
+ */
+function formatStatusBadge(status) {
+    return STATUS_BADGE[status] || status;
+}
+/**
+ * Calculate progress percentage from estimated/spent hours
+ */
+function formatProgress(estimated, spent) {
+    if (!estimated || estimated === 0) {
+        return spent ? `${spent}h spent` : "-";
+    }
+    const percentage = Math.round((spent || 0) / estimated * 100);
+    return `${percentage}%`;
+}
+/**
+ * Format a single version as complete Markdown
+ */
+export function formatVersion(response) {
+    const version = response.version;
+    const lines = [];
+    // Title with status badge
+    lines.push(`# ${version.name} [${formatStatusBadge(version.status)}]`);
+    lines.push("");
+    // Metadata table
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| Project | ${version.project.name} |`);
+    if (version.due_date) {
+        lines.push(`| Due Date | ${version.due_date} |`);
+    }
+    lines.push(`| Status | ${formatStatusBadge(version.status)} |`);
+    if (version.estimated_hours !== undefined || version.spent_hours !== undefined) {
+        const est = version.estimated_hours !== undefined ? `${version.estimated_hours}h` : "-";
+        const spent = version.spent_hours !== undefined ? `${version.spent_hours}h` : "-";
+        lines.push(`| Est/Spent Hours | ${est} / ${spent} |`);
+    }
+    if (version.description) {
+        lines.push(`| Description | ${version.description} |`);
+    }
+    if (version.wiki_page_title) {
+        lines.push(`| Wiki Page | ${version.wiki_page_title} |`);
+    }
+    lines.push(`| Sharing | ${version.sharing} |`);
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Format a list of versions as Markdown table
+ */
+export function formatVersionList(response) {
+    const lines = [];
+    lines.push(`# Versions (${response.total_count})`);
+    lines.push("");
+    if (response.versions.length === 0) {
+        lines.push("No versions found.");
+        return lines.join("\n");
+    }
+    // Table header
+    lines.push("| Name | Status | Due Date | Progress |");
+    lines.push("|------|--------|----------|----------|");
+    for (const version of response.versions) {
+        const status = formatStatusBadge(version.status);
+        const dueDate = version.due_date || "-";
+        const progress = formatProgress(version.estimated_hours, version.spent_hours);
+        lines.push(`| ${version.name} | ${status} | ${dueDate} | ${progress} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/wiki.d.ts

@@ -0,0 +1,11 @@
+import type { RedmineWikiPage, RedmineWikiPagesResponse } from "../redmine/types.js";
+/**
+ * Format a single wiki page as Markdown
+ */
+export declare function formatWikiPage(response: {
+    wiki_page: RedmineWikiPage;
+}): string;
+/**
+ * Format wiki pages list as Markdown
+ */
+export declare function formatWikiPageList(response: RedmineWikiPagesResponse): string;

package/dist/formatters/wiki.js

@@ -0,0 +1,86 @@
+import { formatDate } from "./utils.js";
+/**
+ * Format a single wiki page as Markdown
+ */
+export function formatWikiPage(response) {
+    const page = response.wiki_page;
+    const lines = [];
+    // Title
+    lines.push(`# ${page.title}`);
+    lines.push("");
+    // Metadata line
+    const metaParts = [];
+    metaParts.push(`**Version:** ${page.version}`);
+    metaParts.push(`**Author:** ${page.author.name}`);
+    metaParts.push(`**Updated:** ${formatDate(page.updated_on)}`);
+    if (page.parent) {
+        metaParts.push(`**Parent:** ${page.parent.title}`);
+    }
+    lines.push(metaParts.join(" | "));
+    lines.push("");
+    // Separator
+    lines.push("---");
+    lines.push("");
+    // Content
+    lines.push(page.text);
+    lines.push("");
+    // Attachments
+    if (page.attachments && page.attachments.length > 0) {
+        lines.push("## Attachments");
+        lines.push("");
+        for (const att of page.attachments) {
+            lines.push(`- [${att.filename}](${att.content_url}) (${att.filesize} bytes)`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Build a tree structure from flat wiki page list
+ */
+function buildWikiTree(pages) {
+    const tree = new Map();
+    for (const page of pages) {
+        const parentTitle = page.parent?.title ?? null;
+        if (!tree.has(parentTitle)) {
+            tree.set(parentTitle, []);
+        }
+        tree.get(parentTitle).push(page);
+    }
+    return tree;
+}
+/**
+ * Recursively format wiki pages as tree
+ */
+function formatWikiTree(tree, parentTitle, indent) {
+    const lines = [];
+    const children = tree.get(parentTitle) || [];
+    for (const page of children) {
+        const prefix = "  ".repeat(indent);
+        lines.push(`${prefix}- **${page.title}** (v${page.version})`);
+        // Recursively add children
+        const childLines = formatWikiTree(tree, page.title, indent + 1);
+        lines.push(...childLines);
+    }
+    return lines;
+}
+/**
+ * Format wiki pages list as Markdown
+ */
+export function formatWikiPageList(response) {
+    const pages = response.wiki_pages;
+    const lines = [];
+    // Header
+    lines.push(`# Wiki Pages (${pages.length})`);
+    lines.push("");
+    // Empty case
+    if (pages.length === 0) {
+        lines.push("No wiki pages found.");
+        return lines.join("\n");
+    }
+    // Build tree and format
+    const tree = buildWikiTree(pages);
+    const treeLines = formatWikiTree(tree, null, 0);
+    lines.push(...treeLines);
+    return lines.join("\n");
+}

package/dist/redmine/client.d.ts

@@ -3,6 +3,10 @@ export declare class RedmineClient {
     private baseUrl;
     private apiKey;
     constructor(baseUrl: string, apiKey: string);
+    /**
+     * Get the base URL of the Redmine instance
+     */
+    getBaseUrl(): string;
     private request;
     listIssues(params?: {
         project_id?: string | number;

package/dist/redmine/client.js

@@ -7,6 +7,12 @@ export class RedmineClient {
         // Remove trailing slash if present
         this.baseUrl = baseUrl.replace(/\/$/, "");
     }
+    /**
+     * Get the base URL of the Redmine instance
+     */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
     async request(method, path, body) {
         try {
             const response = await fetch(`${this.baseUrl}${path}`, {

package/dist/server.js

@@ -3,7 +3,7 @@ import { registerTools } from "./tools/index.js";
 export function createServer(redmineClient, toolGroups) {
     const server = new McpServer({
         name: "redmine-mcp",
-        version: "0.4.5",
+        version: "0.5.1",
     });
     registerTools(server, redmineClient, toolGroups);
     return server;

package/dist/tools/account.js

@@ -1,10 +1,16 @@
+import { formatMyAccount } from "../formatters/index.js";
 export function registerAccountTools(server, client) {
     server.registerTool("get_my_account", {
         description: "Get current user account information",
     }, async () => {
         const result = await client.getMyAccount();
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatMyAccount(result) }],
         };
     });
 }

package/dist/tools/admin.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatUser, formatUserList, formatGroup, formatGroupList } from "../formatters/index.js";
 export function registerAdminTools(server, client) {
     // === USERS ===
     server.registerTool("list_users", {
@@ -12,8 +13,13 @@ export function registerAdminTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listUsers(params);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatUserList(result) }],
         };
     });
     server.registerTool("get_user", {
@@ -24,8 +30,13 @@ export function registerAdminTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getUser(params.user_id, params.include);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatUser(result) }],
         };
     });
     server.registerTool("create_user", {
@@ -84,8 +95,13 @@ export function registerAdminTools(server, client) {
         description: "List all groups (admin only)",
     }, async () => {
         const result = await client.listGroups();
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatGroupList(result) }],
         };
     });
     server.registerTool("get_group", {
@@ -96,8 +112,13 @@ export function registerAdminTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getGroup(params.group_id, params.include);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatGroup(result) }],
         };
     });
     server.registerTool("create_group", {

package/dist/tools/agile.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatSprint, formatSprintList, formatAgileData } from "../formatters/index.js";
 export function registerAgileTools(server, client) {
     // === SPRINTS ===
     server.registerTool("list_agile_sprints", {
@@ -8,8 +9,13 @@ export function registerAgileTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listAgileSprints(params.project_id);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatSprintList(result) }],
         };
     });
     server.registerTool("get_agile_sprint", {
@@ -20,8 +26,13 @@ export function registerAgileTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getAgileSprint(params.project_id, params.sprint_id);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatSprint(result) }],
         };
     });
     server.registerTool("create_agile_sprint", {
@@ -81,8 +92,13 @@ export function registerAgileTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getIssueAgileData(params.issue_id);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatAgileData(result) }],
         };
     });
     server.registerTool("update_issue_agile_data", {

package/dist/tools/checklists.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatChecklist, formatChecklistList } from "../formatters/index.js";
 export function registerChecklistsTools(server, client) {
     server.registerTool("list_checklist_items", {
         description: "List all checklist items for an issue (requires redmine_checklists plugin)",
@@ -7,8 +8,13 @@ export function registerChecklistsTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listChecklists(params.issue_id);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatChecklistList(result) }],
         };
     });
     server.registerTool("get_checklist_item", {
@@ -18,8 +24,13 @@ export function registerChecklistsTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getChecklist(params.checklist_id);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatChecklist(result) }],
         };
     });
     server.registerTool("create_checklist_item", {

package/dist/tools/core.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { formatIssueResponse } from "../formatters/index.js";
+import { formatIssueResponse, formatIssueList, formatProject, formatProjectList } from "../formatters/index.js";
 export function registerCoreTools(server, client) {
     // === ISSUES ===
     server.registerTool("list_issues", {
@@ -24,8 +24,13 @@ export function registerCoreTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listIssues(params);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatIssueList(result) }],
         };
     });
     server.registerTool("get_issue", {
@@ -33,6 +38,7 @@ export function registerCoreTools(server, client) {
         inputSchema: {
             issue_id: z.number().describe("The issue ID"),
             include: z.string().optional().describe("Include: attachments, relations, journals, watchers, children, changesets, allowed_statuses"),
+            include_description_diffs: z.boolean().optional().default(false).describe("Include full description diffs in history (can be verbose)"),
         },
     }, async (params) => {
         // Fetch issue and enumerations in parallel
@@ -71,7 +77,9 @@ export function registerCoreTools(server, client) {
         }
         // Format response as Markdown
         return {
-            content: [{ type: "text", text: formatIssueResponse(result, lookup) }],
+            content: [{ type: "text", text: formatIssueResponse(result, lookup, {
+                        includeDescriptionDiffs: params.include_description_diffs,
+                    }) }],
         };
     });
     server.registerTool("create_issue", {
@@ -181,8 +189,13 @@ export function registerCoreTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listProjects(params);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatProjectList(result) }],
         };
     });
     server.registerTool("get_project", {
@@ -193,8 +206,13 @@ export function registerCoreTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getProject(params.project_id, params.include);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatProject(result) }],
         };
     });
     server.registerTool("create_project", {

package/dist/tools/enumerations.js

@@ -1,26 +1,42 @@
+import { formatPriorityList, formatActivityList, formatDocumentCategoryList } from "../formatters/index.js";
 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();
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatPriorityList(result) }],
         };
     });
     server.registerTool("list_time_entry_activities", {
         description: "List all time entry activities with their IDs (Design, Development, etc.)",
     }, async () => {
         const result = await client.listTimeEntryActivities();
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatActivityList(result) }],
         };
     });
     server.registerTool("list_document_categories", {
         description: "List all document categories with their IDs",
     }, async () => {
         const result = await client.listDocumentCategories();
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatDocumentCategoryList(result) }],
         };
     });
 }

package/dist/tools/files.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { readFile } from "fs/promises";
+import { formatAttachment, formatFileList } from "../formatters/index.js";
 export function registerFilesTools(server, client) {
     // === ATTACHMENTS ===
     server.registerTool("get_attachment", {
@@ -9,8 +10,13 @@ export function registerFilesTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getAttachment(params.attachment_id);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatAttachment(result) }],
         };
     });
     server.registerTool("delete_attachment", {
@@ -47,8 +53,13 @@ export function registerFilesTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listProjectFiles(params.project_id);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatFileList(result) }],
         };
     });
     server.registerTool("upload_project_file", {