@pschroee/redmine-mcp 0.4.2 → 0.4.4

package/dist/formatters/index.d.ts

@@ -0,0 +1,2 @@
+export { formatJournals, type NameLookup } 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,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, lookup?: NameLookup): string;
+/**
+ * Format an issue API response as Markdown
+ */
+export declare function formatIssueResponse(response: {
+    issue: RedmineIssue;
+}, lookup?: NameLookup): 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, lookup = {}) {
+    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, lookup));
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an issue API response as Markdown
+ */
+export function formatIssueResponse(response, lookup = {}) {
+    return formatIssue(response.issue, lookup);
+}

package/dist/formatters/journals.d.ts

@@ -0,0 +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[], lookup?: NameLookup): string;

package/dist/formatters/journals.js

@@ -0,0 +1,157 @@
+import { diffLines } from "diff";
+/**
+ * Fields that contain large text and should use diff formatting
+ */
+const LARGE_TEXT_FIELDS = ["description"];
+/**
+ * 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
+ */
+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");
+}
+/**
+ * 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, lookup) {
+    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\`\`\``;
+        }
+        // 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 `- ${displayName}: ${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, lookup) {
+    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, lookup));
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an array of journal entries as Markdown
+ */
+export function formatJournals(journals, lookup = {}) {
+    if (!journals || journals.length === 0) {
+        return "";
+    }
+    const header = `## History (${journals.length} entries)\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.2",
+        version: "0.4.4",
     });
     registerTools(server, redmineClient, toolGroups);
     return server;

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,49 @@ 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);
+        // 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: JSON.stringify(result, null, 2) }],
+            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.2",
+  "version": "0.4.4",
   "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",