@pschroee/redmine-mcp 0.5.0 → 0.5.2

package/dist/formatters/account.d.ts

@@ -0,0 +1,2 @@
+import type { RedmineMyAccountResponse } from "../redmine/types.js";
+export declare function formatMyAccount(response: RedmineMyAccountResponse): string;

package/dist/formatters/account.js

@@ -0,0 +1,48 @@
+import { formatDate } from "./utils.js";
+const USER_STATUS = {
+    1: "Active",
+    2: "Registered",
+    3: "Locked",
+};
+export function formatMyAccount(response) {
+    const user = response.user;
+    const lines = [];
+    lines.push(`# ${user.firstname} ${user.lastname}`);
+    lines.push("");
+    const statusParts = [];
+    statusParts.push(`**Login:** ${user.login}`);
+    if (user.status !== undefined) {
+        statusParts.push(`**Status:** ${USER_STATUS[user.status] || "Unknown"}`);
+    }
+    if (user.admin) {
+        statusParts.push(`**Role:** Admin`);
+    }
+    lines.push(statusParts.join(" | "));
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    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)} |`);
+    }
+    if (user.twofa_scheme) {
+        lines.push(`| 2FA | ${user.twofa_scheme} |`);
+    }
+    if (user.api_key) {
+        lines.push(`| API Key | ${user.api_key} |`);
+    }
+    lines.push("");
+    if (user.custom_fields && user.custom_fields.length > 0) {
+        lines.push("## Custom Fields");
+        lines.push("");
+        lines.push("| Field | Value |");
+        lines.push("|-------|-------|");
+        for (const cf of user.custom_fields) {
+            const value = Array.isArray(cf.value) ? cf.value.join(", ") : cf.value;
+            lines.push(`| ${cf.name} | ${value} |`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}

package/dist/formatters/agile.d.ts

@@ -0,0 +1,6 @@
+import type { RedmineAgileSprint, RedmineAgileSprintsResponse, RedmineAgileDataResponse } from "../redmine/types.js";
+export declare function formatSprint(response: {
+    agile_sprint: RedmineAgileSprint;
+}): string;
+export declare function formatSprintList(response: RedmineAgileSprintsResponse): string;
+export declare function formatAgileData(response: RedmineAgileDataResponse): string;

package/dist/formatters/agile.js

@@ -0,0 +1,53 @@
+export function formatSprint(response) {
+    const sprint = response.agile_sprint;
+    const lines = [];
+    lines.push(`# ${sprint.name}`);
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| ID | ${sprint.id} |`);
+    lines.push(`| Status | ${sprint.status} |`);
+    if (sprint.start_date) {
+        lines.push(`| Start Date | ${sprint.start_date} |`);
+    }
+    if (sprint.end_date) {
+        lines.push(`| End Date | ${sprint.end_date} |`);
+    }
+    if (sprint.description) {
+        lines.push(`| Description | ${sprint.description} |`);
+    }
+    return lines.join("\n");
+}
+export function formatSprintList(response) {
+    const sprints = response.agile_sprints;
+    if (sprints.length === 0) {
+        return "No sprints found.";
+    }
+    const lines = [];
+    lines.push(`# Agile Sprints (${sprints.length})`);
+    lines.push("");
+    lines.push("| ID | Name | Status | Start | End |");
+    lines.push("|----|------|--------|-------|-----|");
+    for (const sprint of sprints) {
+        const start = sprint.start_date || "-";
+        const end = sprint.end_date || "-";
+        lines.push(`| ${sprint.id} | ${sprint.name} | ${sprint.status} | ${start} | ${end} |`);
+    }
+    return lines.join("\n");
+}
+export function formatAgileData(response) {
+    const data = response.agile_data;
+    const lines = [];
+    lines.push(`# Agile Data for Issue #${data.issue_id}`);
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| Position | ${data.position} |`);
+    if (data.story_points !== undefined) {
+        lines.push(`| Story Points | ${data.story_points} |`);
+    }
+    if (data.agile_sprint_id !== undefined) {
+        lines.push(`| Sprint ID | ${data.agile_sprint_id} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/checklist.d.ts

@@ -0,0 +1,5 @@
+import type { RedmineChecklist, RedmineChecklistsResponse } from "../redmine/types.js";
+export declare function formatChecklist(response: {
+    checklist: RedmineChecklist;
+}): string;
+export declare function formatChecklistList(response: RedmineChecklistsResponse): string;

package/dist/formatters/checklist.js

@@ -0,0 +1,30 @@
+export function formatChecklist(response) {
+    const item = response.checklist;
+    const lines = [];
+    lines.push(`# Checklist Item #${item.id}`);
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| Subject | ${item.subject} |`);
+    lines.push(`| Status | ${item.is_done ? "Done" : "Pending"} |`);
+    lines.push(`| Issue | #${item.issue_id} |`);
+    lines.push(`| Position | ${item.position} |`);
+    return lines.join("\n");
+}
+export function formatChecklistList(response) {
+    const items = response.checklists;
+    if (items.length === 0) {
+        return "No checklist items found.";
+    }
+    const sorted = [...items].sort((a, b) => a.position - b.position);
+    const doneCount = items.filter((i) => i.is_done).length;
+    const lines = [];
+    lines.push(`# Checklist (${items.length} items)`);
+    lines.push(`_${doneCount}/${items.length} completed_`);
+    lines.push("");
+    for (const item of sorted) {
+        const checkbox = item.is_done ? "[x]" : "[ ]";
+        lines.push(`- ${checkbox} ${item.subject}`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/file.d.ts

@@ -0,0 +1,5 @@
+import type { RedmineAttachment, RedmineFilesResponse } from "../redmine/types.js";
+export declare function formatAttachment(response: {
+    attachment: RedmineAttachment;
+}): string;
+export declare function formatFileList(response: RedmineFilesResponse): string;

package/dist/formatters/file.js

@@ -0,0 +1,61 @@
+import { formatDate, formatDateShort } from "./utils.js";
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+export function formatAttachment(response) {
+    const att = response.attachment;
+    const lines = [];
+    lines.push(`# ${att.filename}`);
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| ID | ${att.id} |`);
+    lines.push(`| Size | ${formatFileSize(att.filesize)} |`);
+    lines.push(`| Type | ${att.content_type} |`);
+    lines.push(`| Author | ${att.author.name} |`);
+    lines.push(`| Created | ${formatDate(att.created_on)} |`);
+    if (att.description) {
+        lines.push(`| Description | ${att.description} |`);
+    }
+    lines.push("");
+    lines.push(`**Download:** ${att.content_url}`);
+    if (att.thumbnail_url) {
+        lines.push("");
+        lines.push(`**Thumbnail:** ${att.thumbnail_url}`);
+    }
+    return lines.join("\n");
+}
+export function formatFileList(response) {
+    const files = response.files;
+    if (files.length === 0) {
+        return "No files found.";
+    }
+    const lines = [];
+    const hasVersion = files.some((f) => f.version !== undefined);
+    lines.push(`# Project Files (${files.length})`);
+    lines.push("");
+    if (hasVersion) {
+        lines.push("| Filename | Size | Version | Downloads | Author | Date |");
+        lines.push("|----------|------|---------|-----------|--------|------|");
+    }
+    else {
+        lines.push("| Filename | Size | Downloads | Author | Date |");
+        lines.push("|----------|------|-----------|--------|------|");
+    }
+    for (const file of files) {
+        const size = formatFileSize(file.filesize);
+        const date = formatDateShort(file.created_on);
+        if (hasVersion) {
+            const version = file.version?.name || "";
+            lines.push(`| ${file.filename} | ${size} | ${version} | ${file.downloads} | ${file.author.name} | ${date} |`);
+        }
+        else {
+            lines.push(`| ${file.filename} | ${size} | ${file.downloads} | ${file.author.name} | ${date} |`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/formatters/index.d.ts

@@ -7,4 +7,10 @@ export { formatWikiPage, formatWikiPageList } from "./wiki.js";
 export { formatVersion, formatVersionList } from "./version.js";
 export { formatTimeEntry, formatTimeEntryList } from "./time.js";
 export { formatGroup, formatGroupList } from "./group.js";
-export { formatTrackerList, formatStatusList, formatCategoryList, formatPriorityList, formatActivityList, formatRoleList, formatRole, } from "./metadata.js";
+export { formatTrackerList, formatStatusList, formatCategoryList, formatPriorityList, formatActivityList, formatRoleList, formatRole, formatCategory, formatCustomFieldList, formatQueryList, formatDocumentCategoryList, } from "./metadata.js";
+export { formatRelation, formatRelationList } from "./relation.js";
+export { formatAttachment, formatFileList } from "./file.js";
+export { formatMembership, formatMembershipList } from "./membership.js";
+export { formatChecklist, formatChecklistList } from "./checklist.js";
+export { formatSprint, formatSprintList, formatAgileData } from "./agile.js";
+export { formatMyAccount } from "./account.js";

package/dist/formatters/index.js

@@ -7,4 +7,10 @@ export { formatWikiPage, formatWikiPageList } from "./wiki.js";
 export { formatVersion, formatVersionList } from "./version.js";
 export { formatTimeEntry, formatTimeEntryList } from "./time.js";
 export { formatGroup, formatGroupList } from "./group.js";
-export { formatTrackerList, formatStatusList, formatCategoryList, formatPriorityList, formatActivityList, formatRoleList, formatRole, } from "./metadata.js";
+export { formatTrackerList, formatStatusList, formatCategoryList, formatPriorityList, formatActivityList, formatRoleList, formatRole, formatCategory, formatCustomFieldList, formatQueryList, formatDocumentCategoryList, } from "./metadata.js";
+export { formatRelation, formatRelationList } from "./relation.js";
+export { formatAttachment, formatFileList } from "./file.js";
+export { formatMembership, formatMembershipList } from "./membership.js";
+export { formatChecklist, formatChecklistList } from "./checklist.js";
+export { formatSprint, formatSprintList, formatAgileData } from "./agile.js";
+export { formatMyAccount } from "./account.js";

package/dist/formatters/issue.d.ts

@@ -1,15 +1,21 @@
 import type { RedmineIssue, RedmineIssuesResponse } from "../redmine/types.js";
 import { type NameLookup } from "./journals.js";
+/**
+ * Options for formatting issues
+ */
+export interface IssueFormatOptions {
+    includeDescriptionDiffs?: boolean;
+}
 /**
  * Format an issue as complete Markdown
  */
-export declare function formatIssue(issue: RedmineIssue, lookup?: NameLookup): string;
+export declare function formatIssue(issue: RedmineIssue, lookup?: NameLookup, options?: IssueFormatOptions): string;
 /**
  * Format an issue API response as Markdown
  */
 export declare function formatIssueResponse(response: {
     issue: RedmineIssue;
-}, lookup?: NameLookup): string;
+}, lookup?: NameLookup, options?: IssueFormatOptions): string;
 /**
  * Format a list of issues as a Markdown table
  */

package/dist/formatters/issue.js

@@ -1,14 +1,9 @@
 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", " ");
-}
+import { formatDate, formatDateShort } from "./utils.js";
 /**
  * Format an issue as complete Markdown
  */
-export function formatIssue(issue, lookup = {}) {
+export function formatIssue(issue, lookup = {}, options = {}) {
     const lines = [];
     // Title
     lines.push(`# #${issue.id}: ${issue.subject}`);
@@ -116,21 +111,17 @@ export function formatIssue(issue, lookup = {}) {
     }
     // Journals (history)
     if (issue.journals && issue.journals.length > 0) {
-        lines.push(formatJournals(issue.journals, lookup));
+        lines.push(formatJournals(issue.journals, lookup, {
+            includeDescriptionDiffs: options.includeDescriptionDiffs,
+        }));
     }
     return lines.join("\n");
 }
 /**
  * Format an issue API response as Markdown
  */
-export function formatIssueResponse(response, lookup = {}) {
-    return formatIssue(response.issue, lookup);
-}
-/**
- * Format a date string to YYYY-MM-DD format
- */
-function formatDateShort(isoDate) {
-    return new Date(isoDate).toISOString().slice(0, 10);
+export function formatIssueResponse(response, lookup = {}, options = {}) {
+    return formatIssue(response.issue, lookup, options);
 }
 /**
  * Format a list of issues as a Markdown table

package/dist/formatters/journals.d.ts

@@ -4,7 +4,15 @@ import type { RedmineJournal } from "../redmine/types.js";
  * Key: field name (e.g., "status_id"), Value: map of ID -> name
  */
 export type NameLookup = Record<string, Record<string, string>>;
+/**
+ * Options for formatting journals
+ */
+export interface JournalFormatOptions {
+    includeDescriptionDiffs?: boolean;
+}
 /**
  * Format an array of journal entries as Markdown
+ * Entries are displayed in reverse chronological order (newest first)
+ * Note numbers are preserved (1 = oldest, highest = newest)
  */
-export declare function formatJournals(journals: RedmineJournal[], lookup?: NameLookup): string;
+export declare function formatJournals(journals: RedmineJournal[], lookup?: NameLookup, options?: JournalFormatOptions): string;

package/dist/formatters/journals.js

@@ -1,4 +1,5 @@
 import { diffLines } from "diff";
+import { formatDate } from "./utils.js";
 /**
  * Fields that contain large text and should use diff formatting
  */
@@ -68,13 +69,6 @@ const FIELD_DISPLAY_NAMES = {
     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
  */
@@ -116,7 +110,7 @@ function resolveValue(fieldName, value, lookup) {
 /**
  * Format a single journal detail (field change)
  */
-function formatDetail(detail, lookup) {
+function formatDetail(detail, lookup, options = {}) {
     const { property, name, old_value, new_value } = detail;
     // Handle attachment additions/removals
     if (property === "attachment") {
@@ -157,8 +151,11 @@ function formatDetail(detail, lookup) {
             }
             // Fall through to default formatting if parsing failed
         }
-        // Large text fields get diff formatting
+        // Large text fields get diff formatting (only if option enabled)
         if (LARGE_TEXT_FIELDS.includes(name) && old_value && new_value) {
+            if (!options.includeDescriptionDiffs) {
+                return `- ${name}: _(changed - use include_description_diffs to see diff)_`;
+            }
             const diff = generateDiff(old_value, new_value);
             return `- ${name}:\n\`\`\`diff\n${diff}\n\`\`\``;
         }
@@ -181,13 +178,14 @@ function formatDetail(detail, lookup) {
 /**
  * Format a single journal entry as Markdown
  */
-function formatJournalEntry(journal, lookup) {
+function formatJournalEntry(journal, index, lookup, options = {}) {
     const lines = [];
-    // Header with date and user
+    // Header with note number, date and user
+    const noteNum = index + 1;
     const date = formatDate(journal.created_on);
     const user = journal.user.name;
     const privateTag = journal.private_notes ? " 🔒" : "";
-    lines.push(`### ${date} - ${user}${privateTag}`);
+    lines.push(`### #${noteNum} - ${date} - ${user}${privateTag}`);
     lines.push("");
     // Notes (if any)
     if (journal.notes && journal.notes.trim()) {
@@ -198,7 +196,7 @@ function formatJournalEntry(journal, lookup) {
     if (journal.details && journal.details.length > 0) {
         lines.push("**Changes:**");
         for (const detail of journal.details) {
-            lines.push(formatDetail(detail, lookup));
+            lines.push(formatDetail(detail, lookup, options));
         }
         lines.push("");
     }
@@ -206,12 +204,16 @@ function formatJournalEntry(journal, lookup) {
 }
 /**
  * Format an array of journal entries as Markdown
+ * Entries are displayed in reverse chronological order (newest first)
+ * Note numbers are preserved (1 = oldest, highest = newest)
  */
-export function formatJournals(journals, lookup = {}) {
+export function formatJournals(journals, lookup = {}, options = {}) {
     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");
+    // Format entries with their original indices (for note numbers), then reverse for display
+    const formattedEntries = journals.map((j, i) => formatJournalEntry(j, i, lookup, options));
+    const entries = formattedEntries.reverse().join("\n---\n\n");
     return header + entries;
 }

package/dist/formatters/membership.d.ts

@@ -0,0 +1,5 @@
+import type { RedmineMembership, RedmineMembershipsResponse } from "../redmine/types.js";
+export declare function formatMembership(response: {
+    membership: RedmineMembership;
+}): string;
+export declare function formatMembershipList(response: RedmineMembershipsResponse): string;

package/dist/formatters/membership.js

@@ -0,0 +1,41 @@
+function formatRoles(roles) {
+    return roles
+        .map((r) => (r.inherited ? `${r.name} (inherited)` : r.name))
+        .join(", ");
+}
+export function formatMembership(response) {
+    const mem = response.membership;
+    const lines = [];
+    lines.push(`# Membership #${mem.id}`);
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| Project | ${mem.project.name} |`);
+    if (mem.user) {
+        lines.push(`| User | ${mem.user.name} |`);
+    }
+    if (mem.group) {
+        lines.push(`| Group | ${mem.group.name} |`);
+    }
+    lines.push(`| Roles | ${formatRoles(mem.roles)} |`);
+    return lines.join("\n");
+}
+export function formatMembershipList(response) {
+    const memberships = response.memberships;
+    const totalCount = response.total_count;
+    if (memberships.length === 0) {
+        return "No memberships found.";
+    }
+    const lines = [];
+    lines.push(`# Project Memberships (${totalCount})`);
+    lines.push("");
+    lines.push("| ID | User/Group | Type | Roles |");
+    lines.push("|----|------------|------|-------|");
+    for (const mem of memberships) {
+        const name = mem.user?.name || mem.group?.name || "Unknown";
+        const type = mem.user ? "User" : "Group";
+        const roles = formatRoles(mem.roles);
+        lines.push(`| ${mem.id} | ${name} | ${type} | ${roles} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/metadata.d.ts

@@ -55,6 +55,35 @@ interface RedmineRole {
 interface RedmineRolesResponse {
     roles: RedmineRole[];
 }
+interface RedmineCustomField {
+    id: number;
+    name: string;
+    customized_type: string;
+    field_format: string;
+    is_required: boolean;
+    is_filter: boolean;
+    searchable: boolean;
+}
+interface RedmineCustomFieldsResponse {
+    custom_fields: RedmineCustomField[];
+}
+interface RedmineQuery {
+    id: number;
+    name: string;
+    is_public: boolean;
+    project_id?: number;
+}
+interface RedmineQueriesResponse {
+    queries: RedmineQuery[];
+}
+interface RedmineDocumentCategory {
+    id: number;
+    name: string;
+    is_default: boolean;
+}
+interface RedmineDocumentCategoriesResponse {
+    document_categories: RedmineDocumentCategory[];
+}
 /**
  * Format a list of trackers as a Markdown table
  */
@@ -85,4 +114,22 @@ export declare function formatRoleList(response: RedmineRolesResponse): string;
 export declare function formatRole(response: {
     role: RedmineRole;
 }): string;
+/**
+ * Format a single issue category as Markdown
+ */
+export declare function formatCategory(response: {
+    issue_category: RedmineCategory;
+}): string;
+/**
+ * Format a list of custom fields as a Markdown table
+ */
+export declare function formatCustomFieldList(response: RedmineCustomFieldsResponse): string;
+/**
+ * Format a list of saved queries as a Markdown table
+ */
+export declare function formatQueryList(response: RedmineQueriesResponse): string;
+/**
+ * Format a list of document categories as a Markdown table
+ */
+export declare function formatDocumentCategoryList(response: RedmineDocumentCategoriesResponse): string;
 export {};

package/dist/formatters/metadata.js

@@ -135,3 +135,79 @@ export function formatRole(response) {
     }
     return lines.join("\n").trimEnd();
 }
+/**
+ * Format a single issue category as Markdown
+ */
+export function formatCategory(response) {
+    const cat = response.issue_category;
+    const lines = [];
+    lines.push(`# ${cat.name}`);
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| ID | ${cat.id} |`);
+    if (cat.project) {
+        lines.push(`| Project | ${cat.project.name} |`);
+    }
+    if (cat.assigned_to) {
+        lines.push(`| Default Assignee | ${cat.assigned_to.name} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of custom fields as a Markdown table
+ */
+export function formatCustomFieldList(response) {
+    const fields = response.custom_fields;
+    if (fields.length === 0) {
+        return "No custom fields found.";
+    }
+    const lines = [];
+    lines.push(`# Custom Fields (${fields.length})`);
+    lines.push("");
+    lines.push("| ID | Name | Type | Format | Required |");
+    lines.push("|----|------|------|--------|----------|");
+    for (const field of fields) {
+        const required = field.is_required ? "Yes" : "No";
+        lines.push(`| ${field.id} | ${field.name} | ${field.customized_type} | ${field.field_format} | ${required} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of saved queries as a Markdown table
+ */
+export function formatQueryList(response) {
+    const queries = response.queries;
+    if (queries.length === 0) {
+        return "No queries found.";
+    }
+    const lines = [];
+    lines.push(`# Saved Queries (${queries.length})`);
+    lines.push("");
+    lines.push("| ID | Name | Visibility |");
+    lines.push("|----|------|------------|");
+    for (const query of queries) {
+        const visibility = query.is_public ? "Public" : "Private";
+        lines.push(`| ${query.id} | ${query.name} | ${visibility} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of document categories as a Markdown table
+ */
+export function formatDocumentCategoryList(response) {
+    const categories = response.document_categories;
+    if (categories.length === 0) {
+        return "No document categories found.";
+    }
+    const lines = [];
+    lines.push(`# Document Categories (${categories.length})`);
+    lines.push("");
+    lines.push("| ID | Name | Default |");
+    lines.push("|----|------|---------|");
+    for (const cat of categories) {
+        const isDefault = cat.is_default ? "Yes" : "No";
+        lines.push(`| ${cat.id} | ${cat.name} | ${isDefault} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/project.js

@@ -1,14 +1,9 @@
+import { formatDate } from "./utils.js";
 const PROJECT_STATUS = {
     1: "Active",
     5: "Closed",
     9: "Archived",
 };
-/**
- * Format a date string to readable format
- */
-function formatDate(isoDate) {
-    return new Date(isoDate).toISOString().slice(0, 16).replace("T", " ");
-}
 /**
  * Format a single project as complete Markdown
  */

package/dist/formatters/relation.d.ts

@@ -0,0 +1,5 @@
+import type { RedmineRelation, RedmineRelationsResponse } from "../redmine/types.js";
+export declare function formatRelation(response: {
+    relation: RedmineRelation;
+}): string;
+export declare function formatRelationList(response: RedmineRelationsResponse): string;

package/dist/formatters/relation.js

@@ -0,0 +1,55 @@
+const RELATION_LABELS = {
+    relates: "relates",
+    duplicates: "duplicates",
+    duplicated: "duplicated by",
+    blocks: "blocks",
+    blocked: "blocked by",
+    precedes: "precedes",
+    follows: "follows",
+    copied_to: "copied to",
+    copied_from: "copied from",
+};
+export function formatRelation(response) {
+    const rel = response.relation;
+    const lines = [];
+    lines.push(`# Relation #${rel.id}`);
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| Issue | #${rel.issue_id} |`);
+    lines.push(`| Type | ${RELATION_LABELS[rel.relation_type] || rel.relation_type} |`);
+    lines.push(`| Related To | #${rel.issue_to_id} |`);
+    if (rel.delay !== undefined && rel.delay > 0) {
+        lines.push(`| Delay | ${rel.delay} days |`);
+    }
+    return lines.join("\n");
+}
+export function formatRelationList(response) {
+    const relations = response.relations;
+    if (relations.length === 0) {
+        return "No relations found.";
+    }
+    const lines = [];
+    const hasDelay = relations.some((r) => r.delay !== undefined && r.delay > 0);
+    lines.push(`# Issue Relations (${relations.length})`);
+    lines.push("");
+    if (hasDelay) {
+        lines.push("| ID | Issue | Type | Related To | Delay |");
+        lines.push("|----|-------|------|------------|-------|");
+    }
+    else {
+        lines.push("| ID | Issue | Type | Related To |");
+        lines.push("|----|-------|------|------------|");
+    }
+    for (const rel of relations) {
+        const type = RELATION_LABELS[rel.relation_type] || rel.relation_type;
+        if (hasDelay) {
+            const delay = rel.delay ? `${rel.delay} days` : "";
+            lines.push(`| ${rel.id} | #${rel.issue_id} | ${type} | #${rel.issue_to_id} | ${delay} |`);
+        }
+        else {
+            lines.push(`| ${rel.id} | #${rel.issue_id} | ${type} | #${rel.issue_to_id} |`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/formatters/search.js

@@ -1,3 +1,4 @@
+import { formatDateShort, truncate } from "./utils.js";
 /**
  * Get icon for search result type
  */
@@ -13,21 +14,6 @@ function getTypeIcon(type) {
             return "\u{1F4CB}"; // clipboard
     }
 }
-/**
- * Format a date string to YYYY-MM-DD format
- */
-function formatDateShort(isoDate) {
-    return new Date(isoDate).toISOString().slice(0, 10);
-}
-/**
- * Truncate text to a maximum length with ellipsis
- */
-function truncate(text, maxLength) {
-    if (text.length <= maxLength) {
-        return text;
-    }
-    return text.slice(0, maxLength) + "...";
-}
 /**
  * Format a single search result as Markdown
  */

package/dist/formatters/user.js

@@ -1,14 +1,9 @@
+import { formatDate } from "./utils.js";
 const USER_STATUS = {
     1: "Active",
     2: "Registered",
     3: "Locked",
 };
-/**
- * Format a date string to readable format
- */
-function formatDate(isoDate) {
-    return new Date(isoDate).toISOString().slice(0, 16).replace("T", " ");
-}
 /**
  * Format a single user as complete Markdown
  */

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/wiki.js

@@ -1,9 +1,4 @@
-/**
- * Format a date string to readable format (YYYY-MM-DD)
- */
-function formatDate(isoDate) {
-    return new Date(isoDate).toISOString().slice(0, 10);
-}
+import { formatDate } from "./utils.js";
 /**
  * Format a single wiki page as Markdown
  */

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.5.0",
+        version: "0.5.2",
     });
     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/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

@@ -38,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
@@ -76,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", {

package/dist/tools/enumerations.js

@@ -1,4 +1,4 @@
-import { formatPriorityList, formatActivityList } from "../formatters/index.js";
+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)",
@@ -30,8 +30,13 @@ export function registerEnumerationsTools(server, client) {
         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", {

package/dist/tools/memberships.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatMembership, formatMembershipList } from "../formatters/index.js";
 export function registerMembershipsTools(server, client) {
     server.registerTool("list_project_memberships", {
         description: "List all memberships (users and groups) for a project",
@@ -10,8 +11,13 @@ export function registerMembershipsTools(server, client) {
     }, async (params) => {
         const { project_id, ...rest } = params;
         const result = await client.listProjectMemberships(project_id, rest);
+        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: formatMembershipList(result) }],
         };
     });
     server.registerTool("get_membership", {
@@ -21,8 +27,13 @@ export function registerMembershipsTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getMembership(params.membership_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: formatMembership(result) }],
         };
     });
     server.registerTool("create_project_membership", {

package/dist/tools/metadata.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { formatTrackerList, formatStatusList, formatCategoryList } from "../formatters/index.js";
+import { formatTrackerList, formatStatusList, formatCategoryList, formatCategory, formatCustomFieldList, formatQueryList } from "../formatters/index.js";
 export function registerMetadataTools(server, client) {
     // === TRACKERS ===
     server.registerTool("list_trackers", {
@@ -53,8 +53,13 @@ export function registerMetadataTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getIssueCategory(params.category_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: formatCategory(result) }],
         };
     });
     server.registerTool("create_issue_category", {
@@ -102,8 +107,13 @@ export function registerMetadataTools(server, client) {
         description: "List all custom field definitions (requires admin privileges)",
     }, async () => {
         const result = await client.listCustomFields();
+        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: formatCustomFieldList(result) }],
         };
     });
     // === QUERIES ===
@@ -111,8 +121,13 @@ export function registerMetadataTools(server, client) {
         description: "List all saved issue queries (public and private)",
     }, async () => {
         const result = await client.listQueries();
+        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: formatQueryList(result) }],
         };
     });
 }

package/dist/tools/relations.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { formatVersion, formatVersionList } from "../formatters/index.js";
+import { formatVersion, formatVersionList, formatRelation, formatRelationList } from "../formatters/index.js";
 export function registerRelationsTools(server, client) {
     // === ISSUE RELATIONS ===
     server.registerTool("list_issue_relations", {
@@ -9,8 +9,13 @@ export function registerRelationsTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listIssueRelations(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: formatRelationList(result) }],
         };
     });
     server.registerTool("get_relation", {
@@ -20,8 +25,13 @@ export function registerRelationsTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getRelation(params.relation_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: formatRelation(result) }],
         };
     });
     server.registerTool("create_issue_relation", {

package/package.json

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