@pschroee/redmine-mcp 0.4.3 → 0.4.5

package/dist/formatters/index.d.ts

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

package/dist/formatters/issue.d.ts

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

package/dist/formatters/issue.js

@@ -8,7 +8,7 @@ function formatDate(isoDate) {
 /**
  * Format an issue as complete Markdown
  */
-export function formatIssue(issue) {
+export function formatIssue(issue, lookup = {}) {
     const lines = [];
     // Title
     lines.push(`# #${issue.id}: ${issue.subject}`);
@@ -116,13 +116,13 @@ export function formatIssue(issue) {
     }
     // Journals (history)
     if (issue.journals && issue.journals.length > 0) {
-        lines.push(formatJournals(issue.journals));
+        lines.push(formatJournals(issue.journals, lookup));
     }
     return lines.join("\n");
 }
 /**
  * Format an issue API response as Markdown
  */
-export function formatIssueResponse(response) {
-    return formatIssue(response.issue);
+export function formatIssueResponse(response, lookup = {}) {
+    return formatIssue(response.issue, lookup);
 }

package/dist/formatters/journals.d.ts

@@ -1,5 +1,10 @@
 import type { RedmineJournal } from "../redmine/types.js";
+/**
+ * Lookup map for resolving IDs to names
+ * Key: field name (e.g., "status_id"), Value: map of ID -> name
+ */
+export type NameLookup = Record<string, Record<string, string>>;
 /**
  * Format an array of journal entries as Markdown
  */
-export declare function formatJournals(journals: RedmineJournal[]): string;
+export declare function formatJournals(journals: RedmineJournal[], lookup?: NameLookup): string;

package/dist/formatters/journals.js

@@ -3,6 +3,71 @@ import { diffLines } from "diff";
  * Fields that contain large text and should use diff formatting
  */
 const LARGE_TEXT_FIELDS = ["description"];
+/**
+ * Format checklist changes as a readable diff
+ * Only shows items that changed between old and new state
+ */
+function formatChecklistDiff(oldValue, newValue) {
+    let oldItems = [];
+    let newItems = [];
+    try {
+        oldItems = JSON.parse(oldValue || "[]");
+    }
+    catch {
+        // Invalid JSON, fall back to raw display
+        return null;
+    }
+    try {
+        newItems = JSON.parse(newValue || "[]");
+    }
+    catch {
+        return null;
+    }
+    // Create maps for easy lookup by subject (more reliable than ID for diffing)
+    const oldBySubject = new Map(oldItems.map(item => [item.subject, item]));
+    const newBySubject = new Map(newItems.map(item => [item.subject, item]));
+    const changes = [];
+    // Find changed and added items
+    for (const newItem of newItems) {
+        const oldItem = oldBySubject.get(newItem.subject);
+        if (!oldItem) {
+            // New item added
+            const status = newItem.is_done ? "✅" : "❌";
+            changes.push(`  - ➕ ${newItem.subject}: ${status}`);
+        }
+        else if (oldItem.is_done !== newItem.is_done) {
+            // Status changed
+            const oldStatus = oldItem.is_done ? "✅" : "❌";
+            const newStatus = newItem.is_done ? "✅" : "❌";
+            changes.push(`  - ${newItem.subject}: ${oldStatus} → ${newStatus}`);
+        }
+        // If subject and status are same, no change to report
+    }
+    // Find removed items
+    for (const oldItem of oldItems) {
+        if (!newBySubject.has(oldItem.subject)) {
+            const status = oldItem.is_done ? "✅" : "❌";
+            changes.push(`  - ➖ ${oldItem.subject}: ${status}`);
+        }
+    }
+    if (changes.length === 0) {
+        return null; // No meaningful changes
+    }
+    return changes.join("\n");
+}
+/**
+ * Field name mappings for display (remove _id suffix)
+ */
+const FIELD_DISPLAY_NAMES = {
+    status_id: "status",
+    tracker_id: "tracker",
+    priority_id: "priority",
+    assigned_to_id: "assigned_to",
+    category_id: "category",
+    fixed_version_id: "version",
+    parent_id: "parent",
+    project_id: "project",
+};
 /**
  * Format a date string to a readable format
  */
@@ -32,10 +97,26 @@ function generateDiff(oldValue, newValue) {
     }
     return lines.join("\n");
 }
+/**
+ * Resolve an ID value to a display string with name
+ */
+function resolveValue(fieldName, value, lookup) {
+    if (!value)
+        return "_(empty)_";
+    const fieldLookup = lookup[fieldName];
+    if (fieldLookup && fieldLookup[value]) {
+        return `${fieldLookup[value]} (${value})`;
+    }
+    // For parent_id, show as issue reference
+    if (fieldName === "parent_id") {
+        return `#${value}`;
+    }
+    return value;
+}
 /**
  * Format a single journal detail (field change)
  */
-function formatDetail(detail) {
+function formatDetail(detail, lookup) {
     const { property, name, old_value, new_value } = detail;
     // Handle attachment additions/removals
     if (property === "attachment") {
@@ -68,15 +149,31 @@ function formatDetail(detail) {
     }
     // Handle attribute changes
     if (property === "attr") {
+        // Checklist changes get special formatting
+        if (name === "checklist") {
+            const checklistDiff = formatChecklistDiff(old_value || "", new_value || "");
+            if (checklistDiff) {
+                return `- checklist:\n${checklistDiff}`;
+            }
+            // Fall through to default formatting if parsing failed
+        }
         // 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\`\`\``;
         }
+        // Get display name for the field
+        const displayName = FIELD_DISPLAY_NAMES[name] || name;
+        // Resolve ID fields to names
+        if (name.endsWith("_id") && lookup[name]) {
+            const oldDisplay = resolveValue(name, old_value, lookup);
+            const newDisplay = resolveValue(name, new_value, lookup);
+            return `- ${displayName}: ${oldDisplay} → ${newDisplay}`;
+        }
         // Simple field changes
         const oldDisplay = old_value || "_(empty)_";
         const newDisplay = new_value || "_(empty)_";
-        return `- ${name}: ${oldDisplay} → ${newDisplay}`;
+        return `- ${displayName}: ${oldDisplay} → ${newDisplay}`;
     }
     // Fallback for unknown property types
     return `- ${property}.${name}: ${old_value || "_(empty)_"} → ${new_value || "_(empty)_"}`;
@@ -84,7 +181,7 @@ function formatDetail(detail) {
 /**
  * Format a single journal entry as Markdown
  */
-function formatJournalEntry(journal) {
+function formatJournalEntry(journal, lookup) {
     const lines = [];
     // Header with date and user
     const date = formatDate(journal.created_on);
@@ -101,7 +198,7 @@ function formatJournalEntry(journal) {
     if (journal.details && journal.details.length > 0) {
         lines.push("**Changes:**");
         for (const detail of journal.details) {
-            lines.push(formatDetail(detail));
+            lines.push(formatDetail(detail, lookup));
         }
         lines.push("");
     }
@@ -110,11 +207,11 @@ function formatJournalEntry(journal) {
 /**
  * Format an array of journal entries as Markdown
  */
-export function formatJournals(journals) {
+export function formatJournals(journals, lookup = {}) {
     if (!journals || journals.length === 0) {
         return "";
     }
     const header = `## History (${journals.length} entries)\n\n`;
-    const entries = journals.map(formatJournalEntry).join("\n---\n\n");
+    const entries = journals.map(j => formatJournalEntry(j, lookup)).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.3",
+        version: "0.4.5",
     });
     registerTools(server, redmineClient, toolGroups);
     return server;

package/dist/tools/core.js

@@ -35,16 +35,43 @@ export function registerCoreTools(server, client) {
             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);
+        // Fetch issue and enumerations in parallel
+        const [result, statusesResult, trackersResult, prioritiesResult] = await Promise.all([
+            client.getIssue(params.issue_id, params.include),
+            client.listIssueStatuses(),
+            client.listTrackers(),
+            client.listIssuePriorities(),
+        ]);
         // Check if this is an error response
         if ("error" in result) {
             return {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
             };
         }
+        // Build lookup map for ID -> name resolution
+        const lookup = {
+            status_id: {},
+            tracker_id: {},
+            priority_id: {},
+        };
+        if (!("error" in statusesResult)) {
+            for (const s of statusesResult.issue_statuses) {
+                lookup.status_id[String(s.id)] = s.name;
+            }
+        }
+        if (!("error" in trackersResult)) {
+            for (const t of trackersResult.trackers) {
+                lookup.tracker_id[String(t.id)] = t.name;
+            }
+        }
+        if (!("error" in prioritiesResult)) {
+            for (const p of prioritiesResult.issue_priorities) {
+                lookup.priority_id[String(p.id)] = p.name;
+            }
+        }
         // Format response as Markdown
         return {
-            content: [{ type: "text", text: formatIssueResponse(result) }],
+            content: [{ type: "text", text: formatIssueResponse(result, lookup) }],
         };
     });
     server.registerTool("create_issue", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pschroee/redmine-mcp",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "MCP server for Redmine - full API access with configurable tool groups",
   "type": "module",
   "bin": {