@pschroee/redmine-mcp 0.4.5 → 0.5.0

package/dist/formatters/group.d.ts

@@ -0,0 +1,11 @@
+import type { RedmineGroup, RedmineGroupsResponse } from "../redmine/types.js";
+/**
+ * Format a single group as complete Markdown
+ */
+export declare function formatGroup(response: {
+    group: RedmineGroup;
+}): string;
+/**
+ * Format a list of groups as Markdown table
+ */
+export declare function formatGroupList(response: RedmineGroupsResponse): string;

package/dist/formatters/group.js

@@ -0,0 +1,53 @@
+/**
+ * Format a single group as complete Markdown
+ */
+export function formatGroup(response) {
+    const group = response.group;
+    const lines = [];
+    // Header
+    lines.push(`# ${group.name}`);
+    lines.push("");
+    // Users
+    if (group.users && group.users.length > 0) {
+        lines.push("## Users");
+        lines.push("");
+        for (const user of group.users) {
+            lines.push(`- ${user.name}`);
+        }
+        lines.push("");
+    }
+    // Project Memberships
+    if (group.memberships && group.memberships.length > 0) {
+        lines.push("## Project Memberships");
+        lines.push("");
+        for (const membership of group.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 groups as Markdown table
+ */
+export function formatGroupList(response) {
+    const lines = [];
+    // Header
+    lines.push(`# Groups (${response.total_count})`);
+    lines.push("");
+    // Empty case
+    if (response.groups.length === 0) {
+        lines.push("No groups found.");
+        return lines.join("\n");
+    }
+    // Table header
+    lines.push("| ID | Name | Members |");
+    lines.push("|----|------|---------|");
+    // Table rows
+    for (const group of response.groups) {
+        const members = group.users && group.users.length > 0 ? String(group.users.length) : "-";
+        lines.push(`| ${group.id} | ${group.name} | ${members} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/index.d.ts

@@ -1,2 +1,10 @@
 export { formatJournals, type NameLookup } from "./journals.js";
-export { formatIssue, formatIssueResponse } from "./issue.js";
+export { formatIssue, formatIssueResponse, formatIssueList } from "./issue.js";
+export { formatProject, formatProjectList } from "./project.js";
+export { formatUser, formatUserList } from "./user.js";
+export { formatSearchResults } from "./search.js";
+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";

package/dist/formatters/index.js

@@ -1,2 +1,10 @@
 export { formatJournals } from "./journals.js";
-export { formatIssue, formatIssueResponse } from "./issue.js";
+export { formatIssue, formatIssueResponse, formatIssueList } from "./issue.js";
+export { formatProject, formatProjectList } from "./project.js";
+export { formatUser, formatUserList } from "./user.js";
+export { formatSearchResults } from "./search.js";
+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";

package/dist/formatters/issue.d.ts

@@ -1,4 +1,4 @@
-import type { RedmineIssue } from "../redmine/types.js";
+import type { RedmineIssue, RedmineIssuesResponse } from "../redmine/types.js";
 import { type NameLookup } from "./journals.js";
 /**
  * Format an issue as complete Markdown
@@ -10,3 +10,7 @@ export declare function formatIssue(issue: RedmineIssue, lookup?: NameLookup): s
 export declare function formatIssueResponse(response: {
     issue: RedmineIssue;
 }, lookup?: NameLookup): string;
+/**
+ * Format a list of issues as a Markdown table
+ */
+export declare function formatIssueList(response: RedmineIssuesResponse): string;

package/dist/formatters/issue.js

@@ -126,3 +126,45 @@ export function formatIssue(issue, lookup = {}) {
 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);
+}
+/**
+ * Format a list of issues as a Markdown table
+ */
+export function formatIssueList(response) {
+    const { issues, total_count, offset, limit } = response;
+    const lines = [];
+    // Header with count
+    lines.push(`# Issues (${issues.length} of ${total_count})`);
+    lines.push("");
+    // Pagination info if needed
+    if (offset > 0 || total_count > limit) {
+        const start = offset + 1;
+        const end = offset + issues.length;
+        lines.push(`_Showing ${start}-${end} of ${total_count}_`);
+        lines.push("");
+    }
+    // Empty case
+    if (issues.length === 0) {
+        lines.push("No issues found.");
+        return lines.join("\n");
+    }
+    // Table header
+    lines.push("| ID | Subject | Status | Priority | Assigned | Updated |");
+    lines.push("|---|---|---|---|---|---|");
+    // Table rows
+    for (const issue of issues) {
+        const id = `#${issue.id}`;
+        const subject = issue.subject;
+        const status = issue.status.name;
+        const priority = issue.priority.name;
+        const assigned = issue.assigned_to?.name ?? "_(unassigned)_";
+        const updated = formatDateShort(issue.updated_on);
+        lines.push(`| ${id} | ${subject} | ${status} | ${priority} | ${assigned} | ${updated} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/metadata.d.ts

@@ -0,0 +1,88 @@
+interface RedmineTracker {
+    id: number;
+    name: string;
+    description?: string;
+}
+interface RedmineTrackersResponse {
+    trackers: RedmineTracker[];
+}
+interface RedmineIssueStatus {
+    id: number;
+    name: string;
+    is_closed: boolean;
+}
+interface RedmineIssueStatusesResponse {
+    issue_statuses: RedmineIssueStatus[];
+}
+interface RedmineCategory {
+    id: number;
+    name: string;
+    project?: {
+        id: number;
+        name: string;
+    };
+    assigned_to?: {
+        id: number;
+        name: string;
+    };
+}
+interface RedmineCategoriesResponse {
+    issue_categories: RedmineCategory[];
+}
+interface RedminePriority {
+    id: number;
+    name: string;
+    is_default: boolean;
+}
+interface RedminePrioritiesResponse {
+    issue_priorities: RedminePriority[];
+}
+interface RedmineActivity {
+    id: number;
+    name: string;
+    is_default: boolean;
+    active?: boolean;
+}
+interface RedmineActivitiesResponse {
+    time_entry_activities: RedmineActivity[];
+}
+interface RedmineRole {
+    id: number;
+    name: string;
+    assignable?: boolean;
+    permissions?: string[];
+}
+interface RedmineRolesResponse {
+    roles: RedmineRole[];
+}
+/**
+ * Format a list of trackers as a Markdown table
+ */
+export declare function formatTrackerList(response: RedmineTrackersResponse): string;
+/**
+ * Format a list of issue statuses as a Markdown table
+ */
+export declare function formatStatusList(response: RedmineIssueStatusesResponse): string;
+/**
+ * Format a list of issue categories as a Markdown table
+ */
+export declare function formatCategoryList(response: RedmineCategoriesResponse): string;
+/**
+ * Format a list of issue priorities as a Markdown table
+ */
+export declare function formatPriorityList(response: RedminePrioritiesResponse): string;
+/**
+ * Format a list of time entry activities as a Markdown table
+ */
+export declare function formatActivityList(response: RedmineActivitiesResponse): string;
+/**
+ * Format a list of roles as a Markdown table
+ */
+export declare function formatRoleList(response: RedmineRolesResponse): string;
+/**
+ * Format a single role with details as Markdown
+ */
+export declare function formatRole(response: {
+    role: RedmineRole;
+}): string;
+export {};

package/dist/formatters/metadata.js

@@ -0,0 +1,137 @@
+/**
+ * Format a list of trackers as a Markdown table
+ */
+export function formatTrackerList(response) {
+    const lines = [];
+    lines.push("# Trackers");
+    lines.push("");
+    if (response.trackers.length === 0) {
+        lines.push("No trackers found.");
+        return lines.join("\n");
+    }
+    lines.push("| ID | Name |");
+    lines.push("|----|------|");
+    for (const tracker of response.trackers) {
+        lines.push(`| ${tracker.id} | ${tracker.name} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of issue statuses as a Markdown table
+ */
+export function formatStatusList(response) {
+    const lines = [];
+    lines.push("# Issue Statuses");
+    lines.push("");
+    if (response.issue_statuses.length === 0) {
+        lines.push("No statuses found.");
+        return lines.join("\n");
+    }
+    lines.push("| ID | Name | Closed |");
+    lines.push("|----|------|--------|");
+    for (const status of response.issue_statuses) {
+        const closed = status.is_closed ? "Yes" : "No";
+        lines.push(`| ${status.id} | ${status.name} | ${closed} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of issue categories as a Markdown table
+ */
+export function formatCategoryList(response) {
+    const lines = [];
+    lines.push("# Issue Categories");
+    lines.push("");
+    if (response.issue_categories.length === 0) {
+        lines.push("No categories found.");
+        return lines.join("\n");
+    }
+    lines.push("| ID | Name | Assigned To |");
+    lines.push("|----|------|-------------|");
+    for (const category of response.issue_categories) {
+        const assignedTo = category.assigned_to?.name || "";
+        lines.push(`| ${category.id} | ${category.name} | ${assignedTo} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of issue priorities as a Markdown table
+ */
+export function formatPriorityList(response) {
+    const lines = [];
+    lines.push("# Issue Priorities");
+    lines.push("");
+    if (response.issue_priorities.length === 0) {
+        lines.push("No priorities found.");
+        return lines.join("\n");
+    }
+    lines.push("| ID | Name | Default |");
+    lines.push("|----|------|---------|");
+    for (const priority of response.issue_priorities) {
+        const isDefault = priority.is_default ? "Yes" : "No";
+        lines.push(`| ${priority.id} | ${priority.name} | ${isDefault} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of time entry activities as a Markdown table
+ */
+export function formatActivityList(response) {
+    const lines = [];
+    lines.push("# Time Entry Activities");
+    lines.push("");
+    if (response.time_entry_activities.length === 0) {
+        lines.push("No activities found.");
+        return lines.join("\n");
+    }
+    lines.push("| ID | Name | Default | Active |");
+    lines.push("|----|------|---------|--------|");
+    for (const activity of response.time_entry_activities) {
+        const isDefault = activity.is_default ? "Yes" : "No";
+        const isActive = activity.active === undefined ? "" : activity.active ? "Yes" : "No";
+        lines.push(`| ${activity.id} | ${activity.name} | ${isDefault} | ${isActive} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of roles as a Markdown table
+ */
+export function formatRoleList(response) {
+    const lines = [];
+    lines.push("# Roles");
+    lines.push("");
+    if (response.roles.length === 0) {
+        lines.push("No roles found.");
+        return lines.join("\n");
+    }
+    lines.push("| ID | Name | Assignable |");
+    lines.push("|----|------|------------|");
+    for (const role of response.roles) {
+        const assignable = role.assignable === undefined ? "" : role.assignable ? "Yes" : "No";
+        lines.push(`| ${role.id} | ${role.name} | ${assignable} |`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a single role with details as Markdown
+ */
+export function formatRole(response) {
+    const role = response.role;
+    const lines = [];
+    lines.push(`# ${role.name}`);
+    lines.push("");
+    lines.push(`**ID:** ${role.id}`);
+    if (role.assignable !== undefined) {
+        lines.push(`**Assignable:** ${role.assignable ? "Yes" : "No"}`);
+    }
+    lines.push("");
+    if (role.permissions && role.permissions.length > 0) {
+        lines.push("## Permissions");
+        lines.push("");
+        for (const permission of role.permissions) {
+            lines.push(`- ${permission}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}

package/dist/formatters/project.d.ts

@@ -0,0 +1,11 @@
+import type { RedmineProject, RedmineProjectsResponse } from "../redmine/types.js";
+/**
+ * Format a single project as complete Markdown
+ */
+export declare function formatProject(response: {
+    project: RedmineProject;
+}): string;
+/**
+ * Format a list of projects as Markdown
+ */
+export declare function formatProjectList(response: RedmineProjectsResponse): string;

package/dist/formatters/project.js

@@ -0,0 +1,87 @@
+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
+ */
+export function formatProject(response) {
+    const project = response.project;
+    const lines = [];
+    // Title
+    lines.push(`# ${project.name}`);
+    lines.push("");
+    // Status line
+    const statusParts = [];
+    statusParts.push(`**Identifier:** ${project.identifier}`);
+    statusParts.push(`**Status:** ${PROJECT_STATUS[project.status] || "Unknown"}`);
+    statusParts.push(`**Public:** ${project.is_public ? "Yes" : "No"}`);
+    lines.push(statusParts.join(" | "));
+    lines.push("");
+    // Description
+    if (project.description) {
+        lines.push("## Description");
+        lines.push("");
+        lines.push(project.description);
+        lines.push("");
+    }
+    // Metadata table
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    if (project.parent) {
+        lines.push(`| Parent | ${project.parent.name} |`);
+    }
+    if (project.homepage) {
+        lines.push(`| Homepage | ${project.homepage} |`);
+    }
+    lines.push(`| Created | ${formatDate(project.created_on)} |`);
+    lines.push(`| Updated | ${formatDate(project.updated_on)} |`);
+    lines.push("");
+    // Trackers
+    if (project.trackers && project.trackers.length > 0) {
+        lines.push("## Trackers");
+        lines.push("");
+        for (const tracker of project.trackers) {
+            lines.push(`- ${tracker.name}`);
+        }
+        lines.push("");
+    }
+    // Enabled modules
+    if (project.enabled_modules && project.enabled_modules.length > 0) {
+        lines.push("## Enabled Modules");
+        lines.push("");
+        for (const mod of project.enabled_modules) {
+            lines.push(`- ${mod.name}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Format a list of projects as Markdown
+ */
+export function formatProjectList(response) {
+    const lines = [];
+    lines.push(`# Projects (${response.total_count})`);
+    lines.push("");
+    if (response.projects.length === 0) {
+        lines.push("No projects found.");
+        return lines.join("\n");
+    }
+    // Table header
+    lines.push("| Name | Identifier | Status | Public |");
+    lines.push("|------|------------|--------|--------|");
+    for (const project of response.projects) {
+        const status = PROJECT_STATUS[project.status] || "Unknown";
+        const isPublic = project.is_public ? "Yes" : "No";
+        lines.push(`| ${project.name} | ${project.identifier} | ${status} | ${isPublic} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/search.d.ts

@@ -0,0 +1,5 @@
+import type { RedmineSearchResponse } from "../redmine/types.js";
+/**
+ * Format search results as Markdown
+ */
+export declare function formatSearchResults(response: RedmineSearchResponse): string;

package/dist/formatters/search.js

@@ -0,0 +1,75 @@
+/**
+ * Get icon for search result type
+ */
+function getTypeIcon(type) {
+    switch (type.toLowerCase()) {
+        case "issue":
+            return "\u{1F3AB}"; // ticket
+        case "wiki-page":
+            return "\u{1F4C4}"; // page
+        case "project":
+            return "\u{1F4C1}"; // folder
+        default:
+            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
+ */
+function formatSearchResult(result) {
+    const lines = [];
+    const icon = getTypeIcon(result.type);
+    // Title with icon
+    lines.push(`### ${icon} ${result.title}`);
+    // Type and date metadata
+    lines.push(`**Type:** ${result.type} | **Date:** ${formatDateShort(result.datetime)}`);
+    // Description (truncated)
+    if (result.description) {
+        lines.push("");
+        lines.push(truncate(result.description, 200));
+    }
+    return lines.join("\n");
+}
+/**
+ * Format search results as Markdown
+ */
+export function formatSearchResults(response) {
+    const { results, total_count, offset } = response;
+    const lines = [];
+    // Header with count
+    lines.push(`# Search Results (${results.length} of ${total_count})`);
+    lines.push("");
+    // Offset info if applicable
+    if (offset > 0) {
+        lines.push(`_Starting from result ${offset + 1}_`);
+        lines.push("");
+    }
+    // Empty case
+    if (results.length === 0) {
+        lines.push("No results found.");
+        return lines.join("\n");
+    }
+    // Format each result
+    for (let i = 0; i < results.length; i++) {
+        if (i > 0) {
+            lines.push("");
+        }
+        lines.push(formatSearchResult(results[i]));
+    }
+    return lines.join("\n");
+}

package/dist/formatters/time.d.ts

@@ -0,0 +1,11 @@
+import type { RedmineTimeEntry, RedmineTimeEntriesResponse } from "../redmine/types.js";
+/**
+ * Format a single time entry as complete Markdown
+ */
+export declare function formatTimeEntry(response: {
+    time_entry: RedmineTimeEntry;
+}): string;
+/**
+ * Format a list of time entries as Markdown
+ */
+export declare function formatTimeEntryList(response: RedmineTimeEntriesResponse): string;

package/dist/formatters/time.js

@@ -0,0 +1,47 @@
+/**
+ * Format a single time entry as complete Markdown
+ */
+export function formatTimeEntry(response) {
+    const entry = response.time_entry;
+    const lines = [];
+    // Header
+    lines.push(`# Time Entry #${entry.id}`);
+    lines.push("");
+    // Metadata table
+    lines.push("| Field | Value |");
+    lines.push("|-------|-------|");
+    lines.push(`| Project | ${entry.project.name} |`);
+    if (entry.issue) {
+        lines.push(`| Issue | #${entry.issue.id} |`);
+    }
+    lines.push(`| User | ${entry.user.name} |`);
+    lines.push(`| Activity | ${entry.activity.name} |`);
+    lines.push(`| Hours | ${entry.hours} |`);
+    lines.push(`| Date | ${entry.spent_on} |`);
+    if (entry.comments) {
+        lines.push(`| Comments | ${entry.comments} |`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Format a list of time entries as Markdown
+ */
+export function formatTimeEntryList(response) {
+    const lines = [];
+    lines.push(`# Time Entries (${response.total_count})`);
+    lines.push("");
+    if (response.time_entries.length === 0) {
+        lines.push("No time entries found.");
+        return lines.join("\n");
+    }
+    // Table header
+    lines.push("| ID | Date | Hours | User | Activity | Issue | Comments |");
+    lines.push("|----|------|-------|------|----------|-------|----------|");
+    for (const entry of response.time_entries) {
+        const issue = entry.issue ? `#${entry.issue.id}` : "-";
+        const comments = entry.comments || "-";
+        lines.push(`| ${entry.id} | ${entry.spent_on} | ${entry.hours} | ${entry.user.name} | ${entry.activity.name} | ${issue} | ${comments} |`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/user.d.ts

@@ -0,0 +1,11 @@
+import type { RedmineUser, RedmineUsersResponse } from "../redmine/types.js";
+/**
+ * Format a single user as complete Markdown
+ */
+export declare function formatUser(response: {
+    user: RedmineUser;
+}): string;
+/**
+ * Format a list of users as Markdown table
+ */
+export declare function formatUserList(response: RedmineUsersResponse): string;

package/dist/formatters/user.js

@@ -0,0 +1,88 @@
+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
+ */
+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/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,91 @@
+/**
+ * Format a date string to readable format (YYYY-MM-DD)
+ */
+function formatDate(isoDate) {
+    return new Date(isoDate).toISOString().slice(0, 10);
+}
+/**
+ * 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/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.0",
     });
     registerTools(server, redmineClient, toolGroups);
     return server;

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/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", {
@@ -181,8 +186,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 +203,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,18 +1,29 @@
+import { formatPriorityList, formatActivityList } 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", {

package/dist/tools/metadata.js

@@ -1,12 +1,18 @@
 import { z } from "zod";
+import { formatTrackerList, formatStatusList, formatCategoryList } from "../formatters/index.js";
 export function registerMetadataTools(server, client) {
     // === TRACKERS ===
     server.registerTool("list_trackers", {
         description: "List all available trackers (issue types like Bug, Feature, etc.)",
     }, async () => {
         const result = await client.listTrackers();
+        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: formatTrackerList(result) }],
         };
     });
     // === ISSUE STATUSES ===
@@ -14,8 +20,13 @@ export function registerMetadataTools(server, client) {
         description: "List all available issue statuses (New, In Progress, Closed, etc.)",
     }, async () => {
         const result = await client.listIssueStatuses();
+        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: formatStatusList(result) }],
         };
     });
     // === ISSUE CATEGORIES ===
@@ -26,8 +37,13 @@ export function registerMetadataTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listIssueCategories(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: formatCategoryList(result) }],
         };
     });
     server.registerTool("get_issue_category", {

package/dist/tools/relations.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatVersion, formatVersionList } from "../formatters/index.js";
 export function registerRelationsTools(server, client) {
     // === ISSUE RELATIONS ===
     server.registerTool("list_issue_relations", {
@@ -76,8 +77,13 @@ export function registerRelationsTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listVersions(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: formatVersionList(result) }],
         };
     });
     server.registerTool("get_version", {
@@ -87,8 +93,13 @@ export function registerRelationsTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getVersion(params.version_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: formatVersion(result) }],
         };
     });
     server.registerTool("create_version", {

package/dist/tools/roles.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
+import { formatRoleList, formatRole } from "../formatters/index.js";
 export function registerRolesTools(server, client) {
     server.registerTool("list_roles", {
         description: "List all available roles (Manager, Developer, Reporter, etc.)",
     }, async () => {
         const result = await client.listRoles();
+        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: formatRoleList(result) }],
         };
     });
     server.registerTool("get_role", {
@@ -15,8 +21,13 @@ export function registerRolesTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getRole(params.role_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: formatRole(result) }],
         };
     });
 }

package/dist/tools/search.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatSearchResults } from "../formatters/index.js";
 export function registerSearchTools(server, client) {
     server.registerTool("search", {
         description: "Search across Redmine (issues, wiki, news, etc.)",
@@ -21,8 +22,13 @@ export function registerSearchTools(server, client) {
         },
     }, async (params) => {
         const result = await client.search(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: formatSearchResults(result) }],
         };
     });
 }

package/dist/tools/time.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatTimeEntry, formatTimeEntryList } from "../formatters/index.js";
 export function registerTimeTools(server, client) {
     server.registerTool("list_time_entries", {
         description: "List time entries with optional filters",
@@ -13,8 +14,13 @@ export function registerTimeTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listTimeEntries(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: formatTimeEntryList(result) }],
         };
     });
     server.registerTool("get_time_entry", {
@@ -24,8 +30,13 @@ export function registerTimeTools(server, client) {
         },
     }, async (params) => {
         const result = await client.getTimeEntry(params.time_entry_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: formatTimeEntry(result) }],
         };
     });
     server.registerTool("create_time_entry", {

package/dist/tools/wiki.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { formatWikiPage, formatWikiPageList } from "../formatters/index.js";
 export function registerWikiTools(server, client) {
     server.registerTool("list_wiki_pages", {
         description: "List all wiki pages in a project",
@@ -7,8 +8,13 @@ export function registerWikiTools(server, client) {
         },
     }, async (params) => {
         const result = await client.listWikiPages(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: formatWikiPageList(result) }],
         };
     });
     server.registerTool("get_wiki_page", {
@@ -24,8 +30,13 @@ export function registerWikiTools(server, client) {
             version: params.version,
             include: 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: formatWikiPage(result) }],
         };
     });
     server.registerTool("create_wiki_page", {

package/package.json

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