@pschroee/redmine-mcp 0.4.1 → 0.4.3

package/README.md

@@ -331,11 +331,11 @@ Add to your Claude Desktop config (`%APPDATA%\Claude\claude_desktop_config.json`
 
 > Requires [redmine_checklists](https://www.redmineup.com/pages/plugins/checklists) plugin
 
-- `list_checklists` - List checklist items for an issue
-- `get_checklist` - Get checklist item details
-- `create_checklist` - Create checklist item
-- `update_checklist` - Update checklist item (text, done status)
-- `delete_checklist` - Delete checklist item
+- `list_checklist_items` - List checklist items for an issue
+- `get_checklist_item` - Get checklist item details
+- `create_checklist_item` - Create checklist item
+- `update_checklist_item` - Update checklist item (text, done status)
+- `delete_checklist_item` - Delete checklist item
 
 ### Plugin: Agile (plugin_agile)
 

package/dist/formatters/index.d.ts

@@ -0,0 +1,2 @@
+export { formatJournals } from "./journals.js";
+export { formatIssue, formatIssueResponse } from "./issue.js";

package/dist/formatters/index.js

@@ -0,0 +1,2 @@
+export { formatJournals } from "./journals.js";
+export { formatIssue, formatIssueResponse } from "./issue.js";

package/dist/formatters/issue.d.ts

@@ -0,0 +1,11 @@
+import type { RedmineIssue } from "../redmine/types.js";
+/**
+ * Format an issue as complete Markdown
+ */
+export declare function formatIssue(issue: RedmineIssue): string;
+/**
+ * Format an issue API response as Markdown
+ */
+export declare function formatIssueResponse(response: {
+    issue: RedmineIssue;
+}): string;

package/dist/formatters/issue.js

@@ -0,0 +1,128 @@
+import { formatJournals } from "./journals.js";
+/**
+ * Format a date string to readable format
+ */
+function formatDate(isoDate) {
+    return new Date(isoDate).toISOString().slice(0, 16).replace("T", " ");
+}
+/**
+ * Format an issue as complete Markdown
+ */
+export function formatIssue(issue) {
+    const lines = [];
+    // Title
+    lines.push(`# #${issue.id}: ${issue.subject}`);
+    lines.push("");
+    // Status line
+    const statusParts = [];
+    statusParts.push(`**Status:** ${issue.status.name}`);
+    statusParts.push(`**Priority:** ${issue.priority.name}`);
+    if (issue.tracker) {
+        statusParts.push(`**Tracker:** ${issue.tracker.name}`);
+    }
+    if (issue.assigned_to) {
+        statusParts.push(`**Assigned:** ${issue.assigned_to.name}`);
+    }
+    lines.push(statusParts.join(" | "));
+    lines.push("");
+    // Metadata table
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| Project | ${issue.project.name} |`);
+    lines.push(`| Author | ${issue.author.name} |`);
+    lines.push(`| Created | ${formatDate(issue.created_on)} |`);
+    lines.push(`| Updated | ${formatDate(issue.updated_on)} |`);
+    if (issue.closed_on) {
+        lines.push(`| Closed | ${formatDate(issue.closed_on)} |`);
+    }
+    if (issue.start_date) {
+        lines.push(`| Start Date | ${issue.start_date} |`);
+    }
+    if (issue.due_date) {
+        lines.push(`| Due Date | ${issue.due_date} |`);
+    }
+    if (issue.estimated_hours) {
+        lines.push(`| Estimated | ${issue.estimated_hours}h |`);
+    }
+    if (issue.spent_hours) {
+        lines.push(`| Spent | ${issue.spent_hours}h |`);
+    }
+    if (issue.done_ratio !== undefined) {
+        lines.push(`| Progress | ${issue.done_ratio}% |`);
+    }
+    if (issue.category) {
+        lines.push(`| Category | ${issue.category.name} |`);
+    }
+    if (issue.fixed_version) {
+        lines.push(`| Version | ${issue.fixed_version.name} |`);
+    }
+    if (issue.parent) {
+        lines.push(`| Parent | #${issue.parent.id} |`);
+    }
+    lines.push("");
+    // Custom fields
+    if (issue.custom_fields && issue.custom_fields.length > 0) {
+        lines.push("## Custom Fields");
+        lines.push("");
+        for (const cf of issue.custom_fields) {
+            const value = Array.isArray(cf.value) ? cf.value.join(", ") : cf.value;
+            if (value) {
+                lines.push(`- **${cf.name}:** ${value}`);
+            }
+        }
+        lines.push("");
+    }
+    // Description
+    if (issue.description) {
+        lines.push("## Description");
+        lines.push("");
+        lines.push(issue.description);
+        lines.push("");
+    }
+    // Children
+    if (issue.children && issue.children.length > 0) {
+        lines.push("## Subtasks");
+        lines.push("");
+        for (const child of issue.children) {
+            lines.push(`- #${child.id}: ${child.subject} (${child.tracker.name})`);
+        }
+        lines.push("");
+    }
+    // Relations
+    if (issue.relations && issue.relations.length > 0) {
+        lines.push("## Relations");
+        lines.push("");
+        for (const rel of issue.relations) {
+            const target = rel.issue_id === issue.id ? rel.issue_to_id : rel.issue_id;
+            lines.push(`- ${rel.relation_type} #${target}`);
+        }
+        lines.push("");
+    }
+    // Attachments
+    if (issue.attachments && issue.attachments.length > 0) {
+        lines.push("## Attachments");
+        lines.push("");
+        for (const att of issue.attachments) {
+            lines.push(`- [${att.filename}](${att.content_url}) (${att.filesize} bytes)`);
+        }
+        lines.push("");
+    }
+    // Watchers
+    if (issue.watchers && issue.watchers.length > 0) {
+        lines.push("## Watchers");
+        lines.push("");
+        lines.push(issue.watchers.map(w => w.name).join(", "));
+        lines.push("");
+    }
+    // Journals (history)
+    if (issue.journals && issue.journals.length > 0) {
+        lines.push(formatJournals(issue.journals));
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an issue API response as Markdown
+ */
+export function formatIssueResponse(response) {
+    return formatIssue(response.issue);
+}

package/dist/formatters/journals.d.ts

@@ -0,0 +1,5 @@
+import type { RedmineJournal } from "../redmine/types.js";
+/**
+ * Format an array of journal entries as Markdown
+ */
+export declare function formatJournals(journals: RedmineJournal[]): string;

package/dist/formatters/journals.js

@@ -0,0 +1,120 @@
+import { diffLines } from "diff";
+/**
+ * Fields that contain large text and should use diff formatting
+ */
+const LARGE_TEXT_FIELDS = ["description"];
+/**
+ * Format a date string to a readable format
+ */
+function formatDate(isoDate) {
+    const date = new Date(isoDate);
+    return date.toISOString().slice(0, 16).replace("T", " ");
+}
+/**
+ * Generate a unified diff for large text changes
+ */
+function generateDiff(oldValue, newValue) {
+    const changes = diffLines(oldValue || "", newValue || "");
+    const lines = [];
+    for (const change of changes) {
+        const prefix = change.added ? "+" : change.removed ? "-" : " ";
+        const text = change.value.replace(/\n$/, "");
+        // Skip unchanged parts that are too long (context)
+        if (!change.added && !change.removed && text.length > 200) {
+            lines.push("  [...]");
+            continue;
+        }
+        for (const line of text.split("\n")) {
+            if (line || change.added || change.removed) {
+                lines.push(`${prefix} ${line}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a single journal detail (field change)
+ */
+function formatDetail(detail) {
+    const { property, name, old_value, new_value } = detail;
+    // Handle attachment additions/removals
+    if (property === "attachment") {
+        if (new_value && !old_value) {
+            return `- Added attachment: ${new_value}`;
+        }
+        if (old_value && !new_value) {
+            return `- Removed attachment: ${old_value}`;
+        }
+    }
+    // Handle relation changes
+    if (property === "relation") {
+        if (new_value && !old_value) {
+            return `- Added relation: ${name} → #${new_value}`;
+        }
+        if (old_value && !new_value) {
+            return `- Removed relation: ${name} → #${old_value}`;
+        }
+    }
+    // Handle custom fields
+    if (property === "cf") {
+        const fieldName = name;
+        if (!old_value && new_value) {
+            return `- ${fieldName}: _(empty)_ → ${new_value}`;
+        }
+        if (old_value && !new_value) {
+            return `- ${fieldName}: ${old_value} → _(empty)_`;
+        }
+        return `- ${fieldName}: ${old_value} → ${new_value}`;
+    }
+    // Handle attribute changes
+    if (property === "attr") {
+        // Large text fields get diff formatting
+        if (LARGE_TEXT_FIELDS.includes(name) && old_value && new_value) {
+            const diff = generateDiff(old_value, new_value);
+            return `- ${name}:\n\`\`\`diff\n${diff}\n\`\`\``;
+        }
+        // Simple field changes
+        const oldDisplay = old_value || "_(empty)_";
+        const newDisplay = new_value || "_(empty)_";
+        return `- ${name}: ${oldDisplay} → ${newDisplay}`;
+    }
+    // Fallback for unknown property types
+    return `- ${property}.${name}: ${old_value || "_(empty)_"} → ${new_value || "_(empty)_"}`;
+}
+/**
+ * Format a single journal entry as Markdown
+ */
+function formatJournalEntry(journal) {
+    const lines = [];
+    // Header with date and user
+    const date = formatDate(journal.created_on);
+    const user = journal.user.name;
+    const privateTag = journal.private_notes ? " 🔒" : "";
+    lines.push(`### ${date} - ${user}${privateTag}`);
+    lines.push("");
+    // Notes (if any)
+    if (journal.notes && journal.notes.trim()) {
+        lines.push(journal.notes.trim());
+        lines.push("");
+    }
+    // Details (field changes)
+    if (journal.details && journal.details.length > 0) {
+        lines.push("**Changes:**");
+        for (const detail of journal.details) {
+            lines.push(formatDetail(detail));
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an array of journal entries as Markdown
+ */
+export function formatJournals(journals) {
+    if (!journals || journals.length === 0) {
+        return "";
+    }
+    const header = `## History (${journals.length} entries)\n\n`;
+    const entries = journals.map(formatJournalEntry).join("\n---\n\n");
+    return header + entries;
+}

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.1",
+        version: "0.4.3",
     });
     registerTools(server, redmineClient, toolGroups);
     return server;

package/dist/tools/checklists.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export function registerChecklistsTools(server, client) {
-    server.registerTool("list_checklists", {
+    server.registerTool("list_checklist_items", {
         description: "List all checklist items for an issue (requires redmine_checklists plugin)",
         inputSchema: {
             issue_id: z.number().describe("The issue ID to get checklists for"),
@@ -11,7 +11,7 @@ export function registerChecklistsTools(server, client) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool("get_checklist", {
+    server.registerTool("get_checklist_item", {
         description: "Get a specific checklist item by ID (requires redmine_checklists plugin)",
         inputSchema: {
             checklist_id: z.number().describe("The checklist item ID"),
@@ -22,7 +22,7 @@ export function registerChecklistsTools(server, client) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool("create_checklist", {
+    server.registerTool("create_checklist_item", {
         description: "Create a new checklist item for an issue (requires redmine_checklists plugin)",
         inputSchema: {
             issue_id: z.number().describe("The issue ID to add the checklist item to"),
@@ -37,7 +37,7 @@ export function registerChecklistsTools(server, client) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
     });
-    server.registerTool("update_checklist", {
+    server.registerTool("update_checklist_item", {
         description: "Update an existing checklist item (requires redmine_checklists plugin)",
         inputSchema: {
             checklist_id: z.number().describe("The checklist item ID to update"),
@@ -52,7 +52,7 @@ export function registerChecklistsTools(server, client) {
             content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
         };
     });
-    server.registerTool("delete_checklist", {
+    server.registerTool("delete_checklist_item", {
         description: "Delete a checklist item (requires redmine_checklists plugin)",
         inputSchema: {
             checklist_id: z.number().describe("The checklist item ID to delete"),

package/dist/tools/core.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatIssueResponse } from "../formatters/index.js";
 export function registerCoreTools(server, client) {
     // === ISSUES ===
     server.registerTool("list_issues", {
@@ -28,15 +29,22 @@ export function registerCoreTools(server, client) {
         };
     });
     server.registerTool("get_issue", {
-        description: "Get details of a specific issue by ID",
+        description: "Get details of a specific issue by ID. Returns Markdown-formatted response.",
         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);
+        // Check if this is an error response
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        // Format response as Markdown
         return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            content: [{ type: "text", text: formatIssueResponse(result) }],
         };
     });
     server.registerTool("create_issue", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pschroee/redmine-mcp",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "MCP server for Redmine - full API access with configurable tool groups",
   "type": "module",
   "bin": {
@@ -41,10 +41,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "diff": "^8.0.2",
     "zod": "^3.23.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
+    "@types/diff": "^7.0.2",
     "@types/node": "^20.0.0",
     "dotenv": "^17.2.3",
     "eslint": "^9.39.2",