@pschroee/redmine-mcp 0.4.5 → 0.5.1

package/dist/formatters/metadata.d.ts

@@ -0,0 +1,135 @@
+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[];
+}
+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
+ */
+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;
+/**
+ * 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

@@ -0,0 +1,213 @@
+/**
+ * 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();
+}
+/**
+ * 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.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,82 @@
+import { formatDate } from "./utils.js";
+const PROJECT_STATUS = {
+    1: "Active",
+    5: "Closed",
+    9: "Archived",
+};
+/**
+ * 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/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.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,61 @@
+import { formatDateShort, truncate } from "./utils.js";
+/**
+ * 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 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;