@pschroee/redmine-mcp 0.3.1

package/dist/tools/metadata.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+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();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // === ISSUE STATUSES ===
+    server.registerTool("list_issue_statuses", {
+        description: "List all available issue statuses (New, In Progress, Closed, etc.)",
+    }, async () => {
+        const result = await client.listIssueStatuses();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // === ISSUE CATEGORIES ===
+    server.registerTool("list_issue_categories", {
+        description: "List all issue categories for a project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+        },
+    }, async (params) => {
+        const result = await client.listIssueCategories(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_issue_category", {
+        description: "Get details of a specific issue category",
+        inputSchema: {
+            category_id: z.number().describe("The category ID"),
+        },
+    }, async (params) => {
+        const result = await client.getIssueCategory(params.category_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_issue_category", {
+        description: "Create a new issue category in a project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            name: z.string().describe("Category name"),
+            assigned_to_id: z.number().optional().describe("Default assignee user ID for this category"),
+        },
+    }, async (params) => {
+        const { project_id, ...data } = params;
+        const result = await client.createIssueCategory(project_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_issue_category", {
+        description: "Update an existing issue category",
+        inputSchema: {
+            category_id: z.number().describe("The category ID to update"),
+            name: z.string().optional().describe("New category name"),
+            assigned_to_id: z.number().optional().describe("New default assignee user ID"),
+        },
+    }, async (params) => {
+        const { category_id, ...data } = params;
+        const result = await client.updateIssueCategory(category_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("delete_issue_category", {
+        description: "Delete an issue category",
+        inputSchema: {
+            category_id: z.number().describe("The category ID to delete"),
+            reassign_to_id: z.number().optional().describe("Category ID to reassign issues to before deletion"),
+        },
+    }, async (params) => {
+        const result = await client.deleteIssueCategory(params.category_id, params.reassign_to_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    // === CUSTOM FIELDS ===
+    server.registerTool("list_custom_fields", {
+        description: "List all custom field definitions (requires admin privileges)",
+    }, async () => {
+        const result = await client.listCustomFields();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // === QUERIES ===
+    server.registerTool("list_queries", {
+        description: "List all saved issue queries (public and private)",
+    }, async () => {
+        const result = await client.listQueries();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/projects.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerProjectTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/projects.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export function registerProjectTools(server, client) {
+    server.tool("list_projects", "List all accessible projects from Redmine", {
+        limit: z.number().optional().describe("Maximum results (default 25, max 100)"),
+        offset: z.number().optional().describe("Skip first N results"),
+    }, async (params) => {
+        const result = await client.listProjects(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("get_project", "Get details of a specific project", {
+        project_id: z
+            .union([z.string(), z.number()])
+            .describe("Project ID or identifier"),
+    }, async (params) => {
+        const result = await client.getProject(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("create_project", "Create a new project in Redmine", {
+        name: z.string().describe("Project name"),
+        identifier: z
+            .string()
+            .describe("Unique identifier (lowercase, no spaces, used in URLs)"),
+        description: z.string().optional().describe("Project description"),
+        is_public: z.boolean().optional().describe("Whether project is public (default true)"),
+    }, async (params) => {
+        const result = await client.createProject(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.tool("update_project", "Update an existing project", {
+        project_id: z
+            .union([z.string(), z.number()])
+            .describe("Project ID or identifier"),
+        name: z.string().optional().describe("New project name"),
+        description: z.string().optional().describe("New description"),
+        is_public: z.boolean().optional().describe("Change public visibility"),
+    }, async (params) => {
+        const { project_id, ...data } = params;
+        const result = await client.updateProject(project_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/relations.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerRelationsTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/relations.js

@@ -0,0 +1,157 @@
+import { z } from "zod";
+export function registerRelationsTools(server, client) {
+    // === ISSUE RELATIONS ===
+    server.registerTool("list_issue_relations", {
+        description: "List all relations for an issue",
+        inputSchema: {
+            issue_id: z.number().describe("The issue ID"),
+        },
+    }, async (params) => {
+        const result = await client.listIssueRelations(params.issue_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_relation", {
+        description: "Get details of a specific relation",
+        inputSchema: {
+            relation_id: z.number().describe("The relation ID"),
+        },
+    }, async (params) => {
+        const result = await client.getRelation(params.relation_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_issue_relation", {
+        description: "Create a relation between two issues",
+        inputSchema: {
+            issue_id: z.number().describe("The source issue ID"),
+            issue_to_id: z.number().describe("The target issue ID"),
+            relation_type: z
+                .enum([
+                "relates",
+                "duplicates",
+                "duplicated",
+                "blocks",
+                "blocked",
+                "precedes",
+                "follows",
+                "copied_to",
+                "copied_from",
+            ])
+                .describe("Type of relation"),
+            delay: z
+                .number()
+                .optional()
+                .describe("Delay in days (only for precedes/follows)"),
+        },
+    }, async (params) => {
+        const { issue_id, ...data } = params;
+        const result = await client.createIssueRelation(issue_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("delete_relation", {
+        description: "Delete an issue relation",
+        inputSchema: {
+            relation_id: z.number().describe("The relation ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteRelation(params.relation_id);
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) },
+            ],
+        };
+    });
+    // === VERSIONS ===
+    server.registerTool("list_versions", {
+        description: "List all versions (milestones) for a project",
+        inputSchema: {
+            project_id: z
+                .union([z.string(), z.number()])
+                .describe("Project ID or identifier"),
+        },
+    }, async (params) => {
+        const result = await client.listVersions(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_version", {
+        description: "Get details of a specific version",
+        inputSchema: {
+            version_id: z.number().describe("The version ID"),
+        },
+    }, async (params) => {
+        const result = await client.getVersion(params.version_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_version", {
+        description: "Create a new version (milestone) in a project",
+        inputSchema: {
+            project_id: z
+                .union([z.string(), z.number()])
+                .describe("Project ID or identifier"),
+            name: z.string().describe("Version name"),
+            status: z
+                .enum(["open", "locked", "closed"])
+                .optional()
+                .describe("Version status"),
+            sharing: z
+                .enum(["none", "descendants", "hierarchy", "tree", "system"])
+                .optional()
+                .describe("Sharing scope: 'none' (this project only), 'descendants' (with subprojects), 'hierarchy' (with parent/children), 'tree' (whole project tree), 'system' (all projects)"),
+            due_date: z.string().optional().describe("Due date (YYYY-MM-DD)"),
+            description: z.string().optional().describe("Version description"),
+            wiki_page_title: z.string().optional().describe("Associated wiki page"),
+        },
+    }, async (params) => {
+        const { project_id, ...data } = params;
+        const result = await client.createVersion(project_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_version", {
+        description: "Update an existing version",
+        inputSchema: {
+            version_id: z.number().describe("The version ID to update"),
+            name: z.string().optional().describe("New version name"),
+            status: z
+                .enum(["open", "locked", "closed"])
+                .optional()
+                .describe("New status"),
+            sharing: z
+                .enum(["none", "descendants", "hierarchy", "tree", "system"])
+                .optional()
+                .describe("Sharing scope: 'none' (this project only), 'descendants' (with subprojects), 'hierarchy' (with parent/children), 'tree' (whole project tree), 'system' (all projects)"),
+            due_date: z.string().optional().describe("New due date"),
+            description: z.string().optional().describe("New description"),
+            wiki_page_title: z.string().optional().describe("New associated wiki page"),
+        },
+    }, async (params) => {
+        const { version_id, ...data } = params;
+        const result = await client.updateVersion(version_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("delete_version", {
+        description: "Delete a version",
+        inputSchema: {
+            version_id: z.number().describe("The version ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteVersion(params.version_id);
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) },
+            ],
+        };
+    });
+}

package/dist/tools/roles.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerRolesTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/roles.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export function registerRolesTools(server, client) {
+    server.registerTool("list_roles", {
+        description: "List all available roles (Manager, Developer, Reporter, etc.)",
+    }, async () => {
+        const result = await client.listRoles();
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_role", {
+        description: "Get role details including permissions",
+        inputSchema: {
+            role_id: z.number().describe("Role ID"),
+        },
+    }, async (params) => {
+        const result = await client.getRole(params.role_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/search.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerSearchTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/search.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export function registerSearchTools(server, client) {
+    server.registerTool("search", {
+        description: "Search across Redmine (issues, wiki, news, etc.)",
+        inputSchema: {
+            q: z.string().describe("Search query"),
+            scope: z.enum(["all", "my_projects", "subprojects"]).optional().describe("Search scope"),
+            all_words: z.boolean().optional().describe("Match all words (default true)"),
+            titles_only: z.boolean().optional().describe("Search only in titles"),
+            open_issues: z.boolean().optional().describe("Only open issues"),
+            attachments: z.enum(["0", "1", "only"]).optional().describe("Search attachments: 0=no, 1=yes, only=only attachments"),
+            issues: z.boolean().optional().describe("Include issues in results"),
+            news: z.boolean().optional().describe("Include news in results"),
+            documents: z.boolean().optional().describe("Include documents in results"),
+            changesets: z.boolean().optional().describe("Include changesets in results"),
+            wiki_pages: z.boolean().optional().describe("Include wiki pages in results"),
+            messages: z.boolean().optional().describe("Include forum messages in results"),
+            projects: z.boolean().optional().describe("Include projects in results"),
+            limit: z.number().optional().describe("Maximum results"),
+            offset: z.number().optional().describe("Skip first N results"),
+        },
+    }, async (params) => {
+        const result = await client.search(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/tools/time.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerTimeTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/time.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+export function registerTimeTools(server, client) {
+    server.registerTool("list_time_entries", {
+        description: "List time entries with optional filters",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).optional().describe("Filter by project ID or identifier"),
+            user_id: z.union([z.number(), z.string()]).optional().describe("Filter by user ID or 'me'"),
+            spent_on: z.string().optional().describe("Filter by exact date (YYYY-MM-DD)"),
+            from: z.string().optional().describe("Filter from date (YYYY-MM-DD)"),
+            to: z.string().optional().describe("Filter to date (YYYY-MM-DD)"),
+            limit: z.number().optional().describe("Maximum results (default 25, max 100)"),
+            offset: z.number().optional().describe("Skip first N results"),
+        },
+    }, async (params) => {
+        const result = await client.listTimeEntries(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_time_entry", {
+        description: "Get details of a specific time entry",
+        inputSchema: {
+            time_entry_id: z.number().describe("The time entry ID"),
+        },
+    }, async (params) => {
+        const result = await client.getTimeEntry(params.time_entry_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_time_entry", {
+        description: "Log time on an issue or project",
+        inputSchema: {
+            issue_id: z.number().optional().describe("Issue ID to log time on (either issue_id or project_id required)"),
+            project_id: z.union([z.string(), z.number()]).optional().describe("Project ID to log time on (either issue_id or project_id required)"),
+            hours: z.number().describe("Number of hours spent"),
+            activity_id: z.number().optional().describe("Activity ID (use list_time_entry_activities to get IDs)"),
+            spent_on: z.string().optional().describe("Date spent (YYYY-MM-DD, defaults to today)"),
+            comments: z.string().optional().describe("Description of work done (max 255 chars)"),
+            user_id: z.number().optional().describe("User ID to log time for (admin only)"),
+        },
+    }, async (params) => {
+        const result = await client.createTimeEntry(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_time_entry", {
+        description: "Update an existing time entry",
+        inputSchema: {
+            time_entry_id: z.number().describe("The time entry ID to update"),
+            hours: z.number().optional().describe("New hours value"),
+            activity_id: z.number().optional().describe("New activity ID"),
+            spent_on: z.string().optional().describe("New date (YYYY-MM-DD)"),
+            comments: z.string().optional().describe("New comments"),
+        },
+    }, async (params) => {
+        const { time_entry_id, ...data } = params;
+        const result = await client.updateTimeEntry(time_entry_id, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+    server.registerTool("delete_time_entry", {
+        description: "Delete a time entry",
+        inputSchema: {
+            time_entry_id: z.number().describe("The time entry ID to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteTimeEntry(params.time_entry_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+}

package/dist/tools/wiki.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RedmineClient } from "../redmine/client.js";
+export declare function registerWikiTools(server: McpServer, client: RedmineClient): void;

package/dist/tools/wiki.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+export function registerWikiTools(server, client) {
+    server.registerTool("list_wiki_pages", {
+        description: "List all wiki pages in a project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+        },
+    }, async (params) => {
+        const result = await client.listWikiPages(params.project_id);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("get_wiki_page", {
+        description: "Get content of a specific wiki page",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            page_name: z.string().describe("Wiki page name/title"),
+            version: z.number().optional().describe("Specific version number to retrieve"),
+            include: z.string().optional().describe("Include: attachments"),
+        },
+    }, async (params) => {
+        const result = await client.getWikiPage(params.project_id, params.page_name, {
+            version: params.version,
+            include: params.include,
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("create_wiki_page", {
+        description: "Create a new wiki page in a project",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            page_name: z.string().describe("Wiki page name/title (used in URL)"),
+            text: z.string().describe("Page content (supports Textile/Markdown)"),
+            comments: z.string().optional().describe("Edit comment for version history"),
+            parent_title: z.string().optional().describe("Parent page title for hierarchy"),
+        },
+    }, async (params) => {
+        const { project_id, page_name, ...data } = params;
+        const result = await client.createOrUpdateWikiPage(project_id, page_name, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("update_wiki_page", {
+        description: "Update an existing wiki page",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            page_name: z.string().describe("Wiki page name/title"),
+            text: z.string().describe("New page content"),
+            comments: z.string().optional().describe("Edit comment for version history"),
+            version: z.number().optional().describe("Expected version for conflict detection"),
+        },
+    }, async (params) => {
+        const { project_id, page_name, ...data } = params;
+        const result = await client.createOrUpdateWikiPage(project_id, page_name, data);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("delete_wiki_page", {
+        description: "Delete a wiki page and all its history",
+        inputSchema: {
+            project_id: z.union([z.string(), z.number()]).describe("Project ID or identifier"),
+            page_name: z.string().describe("Wiki page name/title to delete"),
+        },
+    }, async (params) => {
+        const result = await client.deleteWikiPage(params.project_id, params.page_name);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result ?? { success: true }, null, 2) }],
+        };
+    });
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@pschroee/redmine-mcp",
+  "version": "0.3.1",
+  "description": "MCP server for Redmine - full API access with configurable tool groups",
+  "type": "module",
+  "bin": {
+    "redmine-mcp": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "prepublishOnly": "npm run lint && npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "mcp",
+    "redmine",
+    "claude"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pschroee/redmine-mcp.git"
+  },
+  "homepage": "https://github.com/pschroee/redmine-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/pschroee/redmine-mcp/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^20.0.0",
+    "dotenv": "^17.2.3",
+    "eslint": "^9.39.2",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.52.0",
+    "vitest": "^4.0.16"
+  }
+}