@pschroee/redmine-mcp 0.4.5 → 0.5.1

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/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,16 @@
 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, 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

@@ -1,2 +1,16 @@
 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, 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,12 +1,22 @@
-import type { RedmineIssue } from "../redmine/types.js";
+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
+ */
+export declare function formatIssueList(response: RedmineIssuesResponse): string;

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,13 +111,51 @@ 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);
+export function formatIssueResponse(response, lookup = {}, options = {}) {
+    return formatIssue(response.issue, lookup, options);
+}
+/**
+ * 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.d.ts

@@ -4,7 +4,13 @@ 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
  */
-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("");
     }
@@ -207,11 +205,11 @@ function formatJournalEntry(journal, lookup) {
 /**
  * Format an array of journal entries as Markdown
  */
-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");
+    const entries = journals.map((j, i) => formatJournalEntry(j, i, lookup, options)).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");
+}