@pschroee/redmine-mcp 0.4.4 → 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/journals.js

@@ -3,6 +3,58 @@ import { diffLines } from "diff";
  * Fields that contain large text and should use diff formatting
  */
 const LARGE_TEXT_FIELDS = ["description"];
+/**
+ * Format checklist changes as a readable diff
+ * Only shows items that changed between old and new state
+ */
+function formatChecklistDiff(oldValue, newValue) {
+    let oldItems = [];
+    let newItems = [];
+    try {
+        oldItems = JSON.parse(oldValue || "[]");
+    }
+    catch {
+        // Invalid JSON, fall back to raw display
+        return null;
+    }
+    try {
+        newItems = JSON.parse(newValue || "[]");
+    }
+    catch {
+        return null;
+    }
+    // Create maps for easy lookup by subject (more reliable than ID for diffing)
+    const oldBySubject = new Map(oldItems.map(item => [item.subject, item]));
+    const newBySubject = new Map(newItems.map(item => [item.subject, item]));
+    const changes = [];
+    // Find changed and added items
+    for (const newItem of newItems) {
+        const oldItem = oldBySubject.get(newItem.subject);
+        if (!oldItem) {
+            // New item added
+            const status = newItem.is_done ? "✅" : "❌";
+            changes.push(`  - ➕ ${newItem.subject}: ${status}`);
+        }
+        else if (oldItem.is_done !== newItem.is_done) {
+            // Status changed
+            const oldStatus = oldItem.is_done ? "✅" : "❌";
+            const newStatus = newItem.is_done ? "✅" : "❌";
+            changes.push(`  - ${newItem.subject}: ${oldStatus} → ${newStatus}`);
+        }
+        // If subject and status are same, no change to report
+    }
+    // Find removed items
+    for (const oldItem of oldItems) {
+        if (!newBySubject.has(oldItem.subject)) {
+            const status = oldItem.is_done ? "✅" : "❌";
+            changes.push(`  - ➖ ${oldItem.subject}: ${status}`);
+        }
+    }
+    if (changes.length === 0) {
+        return null; // No meaningful changes
+    }
+    return changes.join("\n");
+}
 /**
  * Field name mappings for display (remove _id suffix)
  */
@@ -97,6 +149,14 @@ function formatDetail(detail, lookup) {
     }
     // Handle attribute changes
     if (property === "attr") {
+        // Checklist changes get special formatting
+        if (name === "checklist") {
+            const checklistDiff = formatChecklistDiff(old_value || "", new_value || "");
+            if (checklistDiff) {
+                return `- checklist:\n${checklistDiff}`;
+            }
+            // Fall through to default formatting if parsing failed
+        }
         // Large text fields get diff formatting
         if (LARGE_TEXT_FIELDS.includes(name) && old_value && new_value) {
             const diff = generateDiff(old_value, new_value);

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;