@muzzamil-khan/redmine-agent-mcp 1.0.0 → 1.2.0

package/dist/mcp/server.js

@@ -3,155 +3,727 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod/v4";
 import { logTimeWorkflow } from "../workflows/logTimeWorkflow.js";
+import { createIssueWorkflow } from "../workflows/createIssueWorkflow.js";
+import { batchCreateIssuesWorkflow } from "../workflows/batchCreateIssuesWorkflow.js";
+import { bulkUpdateIssuesWorkflow } from "../workflows/bulkUpdateIssuesWorkflow.js";
+import { sheetToCsvWorkflow } from "../workflows/sheetToCsvWorkflow.js";
+import { getAllUsersWorkflow } from "../workflows/getAllUsersWorkflow.js";
 import { workflowToMcpContent } from "../utils/mcpResponse.js";
-const server = new McpServer({
-    name: "redmine-agent",
-    version: "3.4.1",
-}, {
-    instructions: `Local Redmine tool: batch log time only (redmine_agent_log_time).
-When needsInput and data.batchMode is true, show ALL items in questions[] in ONE AskQuestion. dateIssues ids are YYYY-MM-DD; pairHours/pairComments ids are YYYY-MM-DD:issueId.
-Flow: dates → batch dateIssues → batch pairHours → batch pairComments → preview → confirmSave=yes (no yes/no pair step).`,
-});
-server.registerTool("redmine_agent_log_time", {
-    description: "Batch log time: dates → batch dateIssues (per date, one page) → batch pairHours → batch pairComments → preview → confirmSave=yes. Selecting issues per date defines what to log; no pairInclude step.",
-    inputSchema: {
-        promptHint: z
-            .string()
-            .optional()
-            .describe("User message text; if it mentions 'today', date step is skipped"),
-        dates: z
-            .array(z.string())
-            .optional()
-            .describe("Step 1 — Today | Multiple | Other, or YYYY-MM-DD list"),
-        spentOn: z
-            .string()
-            .optional()
-            .describe("Custom date YYYY-MM-DD when Other was chosen"),
-        pendingDates: z.array(z.string()).optional(),
-        activeDate: z.string().optional(),
-        dateIssues: z
-            .record(z.string(), z.union([
-            z.array(z.number().int().positive()),
-            z.string(),
-        ]))
-            .optional()
-            .describe("Step 2 batch — issue IDs per date (number[] or comma-separated string)"),
-        pendingIssueIds: z.array(z.number().int().positive()).optional(),
-        activeIssueId: z.number().int().positive().optional(),
-        issueIds: z
-            .array(z.number().int().positive())
-            .optional()
-            .describe("Legacy — fills all dates if dateIssues omitted (single date only)"),
-        pairInclude: z
-            .enum(["yes", "no"])
-            .optional()
-            .describe("Legacy single pair; prefer pairIncludes"),
-        pairIncludes: z
-            .record(z.string(), z.string())
-            .optional()
-            .describe('Step 3 batch — all yes/no keyed by "YYYY-MM-DD:issueId"'),
-        pairHours: z
-            .record(z.string(), z.union([z.number(), z.string()]))
-            .optional()
-            .describe("Step 4 batch — hours per included pair key"),
-        pairComments: z
-            .record(z.string(), z.string())
-            .optional()
-            .describe('Step 5 batch — "default" or custom text per pair key'),
-        issueSubjects: z
-            .record(z.string(), z.string())
-            .optional()
-            .describe("issueId → subject; pass back from data for question labels"),
-        issueOptions: z
-            .array(z.object({
-            issueId: z.number().int().positive(),
-            subject: z.string().optional(),
-            label: z.string().optional(),
-        }))
-            .optional(),
-        skippedPairs: z
-            .array(z.string())
-            .optional()
-            .describe('Skipped pair keys "YYYY-MM-DD:issueId"'),
-        issueId: z.number().int().positive().optional(),
-        hours: z.number().positive().optional().describe("Legacy single pair hours"),
-        commentChoice: z.enum(["default", "custom"]).optional(),
-        comments: z.string().optional(),
-        entries: z
-            .array(z.object({
-            issueId: z.number().int().positive(),
-            hours: z.number().positive(),
-            spentOn: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-            comments: z.string(),
-        }))
-            .optional(),
-        confirmSave: z.enum(["yes", "no"]).optional(),
-    },
-}, async (input) => workflowToMcpContent(await logTimeWorkflow({
-    ...(input.promptHint !== undefined
-        ? { promptHint: input.promptHint }
-        : {}),
-    ...(input.dates !== undefined ? { dates: input.dates } : {}),
-    ...(input.spentOn !== undefined
-        ? { spentOn: input.spentOn }
-        : {}),
-    ...(input.pendingDates !== undefined
-        ? { pendingDates: input.pendingDates }
-        : {}),
-    ...(input.activeDate !== undefined
-        ? { activeDate: input.activeDate }
-        : {}),
-    ...(input.dateIssues !== undefined
-        ? { dateIssues: input.dateIssues }
-        : {}),
-    ...(input.pendingIssueIds !== undefined
-        ? { pendingIssueIds: input.pendingIssueIds }
-        : {}),
-    ...(input.activeIssueId !== undefined
-        ? { activeIssueId: input.activeIssueId }
-        : {}),
-    ...(input.issueIds !== undefined
-        ? { issueIds: input.issueIds }
-        : {}),
-    ...(input.issueId !== undefined
-        ? { issueId: input.issueId }
-        : {}),
-    ...(input.hours !== undefined ? { hours: input.hours } : {}),
-    ...(input.pairInclude !== undefined
-        ? { pairInclude: input.pairInclude }
-        : {}),
-    ...(input.pairIncludes !== undefined
-        ? { pairIncludes: input.pairIncludes }
-        : {}),
-    ...(input.pairHours !== undefined
-        ? { pairHours: input.pairHours }
-        : {}),
-    ...(input.pairComments !== undefined
-        ? { pairComments: input.pairComments }
-        : {}),
-    ...(input.issueSubjects !== undefined
-        ? { issueSubjects: input.issueSubjects }
-        : {}),
-    ...(input.issueOptions !== undefined
-        ? { issueOptions: input.issueOptions }
-        : {}),
-    ...(input.skippedPairs !== undefined
-        ? { skippedPairs: input.skippedPairs }
-        : {}),
-    ...(input.commentChoice !== undefined
-        ? { commentChoice: input.commentChoice }
-        : {}),
-    ...(input.comments !== undefined
-        ? { comments: input.comments }
-        : {}),
-    ...(input.entries !== undefined
-        ? { entries: input.entries }
-        : {}),
-    ...(input.confirmSave !== undefined
-        ? { confirmSave: input.confirmSave }
-        : {}),
-})));
+import { getCurrentUserWithMemberships, getRolePermissions, } from "../services/redmine.js";
+import { configOptionsPayload, formatConfigForInstructions, formatEnumerationLine, loadRedmineConfig, } from "../services/redmineConfig.js";
+const BASE_MCP_INSTRUCTIONS = `Local Redmine tools: redmine_agent_log_time, redmine_agent_create_issue, redmine_agent_sheet_to_csv, redmine_agent_batch_create_issues, redmine_agent_bulk_update_issues, redmine_agent_get_all_users, redmine_agent_get_config.
+Log time: when needsInput and data.batchMode is true, show ALL items in questions[] in ONE AskQuestion. Flow: dates → dateIssues → pairHours → pairActivities (mandatory; options from server config cache, not a separate MCP call) → pairComments → confirmSave=yes.
+Create issue: when needsInput and data.batchMode is true, show ALL questions[] in ONE AskQuestion. Flow: full intake → preview → confirmSave=yes. Use tracker/status/priority names or ids from loaded config; tracker aliases CR→Change Request, bug→Bug, story→User Story.
+Sheet batch: get_sheet_data → sheet_to_csv → redmine_agent_get_config → batch_create_issues. Steps: pick_project → pick_target_version (always AskQuestion; select existing, Other → Create: <name>, or Skip) → map_columns (use suggestedColumnMapping) → confirm_mapping → fix_batch_gaps (priorityNameFixes/trackerNameFixes/statusNameFixes from config) → fix_assignees → preview_gate → proceed. Never upload on first batch call.
+Bulk update: get_sheet_data → sheet_to_csv → redmine_agent_bulk_update_issues. Steps: pick_project → map_columns (use suggestedColumnMapping) → confirm_mapping → fix_status_gaps if needed → preview_gate → previewAction proceed. Matches tasks by Ticket:#id or exact task title (subtask column); updates description + status from sheet.
+Get users: redmine_agent_get_all_users lists members from projects you belong to (project memberships), not global /users. Use assigneeOptions for spreadsheet Assigned To matching.
+Get config: redmine_agent_get_config returns live trackers, activities, priorities, statuses (same cache as MCP connect).
+Do NOT use team redmine create_issue for full task creation — use redmine_agent_create_issue or redmine_agent_batch_create_issues.`;
+function enumerationDescribe(label, rows, aliasHint) {
+    const line = formatEnumerationLine(label, rows).replace(`${label}: `, "");
+    return `${label} name or id. Options: ${line}${aliasHint ? `. ${aliasHint}` : ""}`;
+}
+function registerTools(server, config) {
+    const trackerDescribe = `${enumerationDescribe("Tracker", config.trackers, "Aliases: CR→Change Request, bug→Bug, story→User Story")}`;
+    const statusDescribe = `${enumerationDescribe("Status", config.statuses, "Aliases: on hold→Waiting for Support, dev done→Ready For QA, done→Closed, deployed on preprod→Pre-production, ready for preprod→Move to preprod, verified preprod→Ok for Release, to do→New, review→Code Review")}`;
+    const priorityDescribe = `${enumerationDescribe("Priority", config.priorities, "Aliases: medium→Normal, highest→Immediate, lowest→Low")}`;
+    server.registerTool("redmine_agent_get_config", {
+        description: "Redmine enumerations loaded at MCP connect (activities, trackers, priorities, statuses) with id↔name mapping and aliases. Optional force=true refreshes cache.",
+        inputSchema: {
+            force: z
+                .boolean()
+                .optional()
+                .describe("Bypass TTL and refetch from Redmine API"),
+        },
+    }, async (input) => {
+        const fresh = await loadRedmineConfig({
+            ...(input.force ? { force: true } : {}),
+        });
+        return workflowToMcpContent({
+            success: true,
+            data: configOptionsPayload(fresh),
+        });
+    });
+    server.registerTool("redmine_agent_create_issue", {
+        description: "Create a Redmine issue end-to-end: batched intake (all fields), preview, confirmSave=yes upload. Supports tracker, status, priority, dates, estimate, assignee, target version, parent task, and custom fields. Use this instead of team redmine create_issue.",
+        inputSchema: {
+            project: z
+                .string()
+                .optional()
+                .describe("Redmine project identifier or numeric project ID"),
+            tracker: z
+                .string()
+                .optional()
+                .describe(trackerDescribe),
+            subjectMode: z.enum(["default", "blank", "custom"]).optional(),
+            subjectCustom: z.string().optional(),
+            descriptionMode: z.enum(["default", "blank", "custom"]).optional(),
+            descriptionCustom: z.string().optional(),
+            status: z
+                .string()
+                .optional()
+                .describe(statusDescribe),
+            priority: z
+                .string()
+                .optional()
+                .describe(priorityDescribe),
+            assignedToMode: z.enum(["default", "blank", "custom"]).optional(),
+            assignedToCustom: z.string().optional(),
+            targetVersionMode: z.enum(["default", "blank", "custom"]).optional(),
+            targetVersionCustom: z.string().optional(),
+            parentTaskMode: z.enum(["default", "blank", "custom"]).optional(),
+            parentTaskCustom: z.string().optional(),
+            startDateMode: z.enum(["default", "blank", "custom"]).optional(),
+            startDateCustom: z.string().optional(),
+            dueDateMode: z.enum(["default", "blank", "custom"]).optional(),
+            dueDateCustom: z.string().optional(),
+            estimatedTimeMode: z.enum(["default", "blank", "custom"]).optional(),
+            estimatedTimeCustom: z.string().optional(),
+            qaStatusMode: z.enum(["default", "blank", "custom"]).optional(),
+            qaStatusCustom: z.string().optional(),
+            gitLinkMode: z.enum(["default", "blank", "custom"]).optional(),
+            gitLinkCustom: z.string().optional(),
+            gitLink1Mode: z.enum(["default", "blank", "custom"]).optional(),
+            gitLink1Custom: z.string().optional(),
+            gitLink2Mode: z.enum(["default", "blank", "custom"]).optional(),
+            gitLink2Custom: z.string().optional(),
+            expectedTimeMode: z.enum(["default", "blank", "custom"]).optional(),
+            expectedTimeCustom: z.string().optional(),
+            prLinkMode: z.enum(["default", "blank", "custom"]).optional(),
+            prLinkCustom: z.string().optional(),
+            storyPointsMode: z.enum(["default", "blank", "custom"]).optional(),
+            storyPointsCustom: z.string().optional(),
+            confirmSave: z.enum(["yes", "no"]).optional(),
+        },
+    }, async (input) => workflowToMcpContent(await createIssueWorkflow({
+        ...(input.project !== undefined ? { project: input.project } : {}),
+        ...(input.tracker !== undefined ? { tracker: input.tracker } : {}),
+        ...(input.subjectMode !== undefined
+            ? { subjectMode: input.subjectMode }
+            : {}),
+        ...(input.subjectCustom !== undefined
+            ? { subjectCustom: input.subjectCustom }
+            : {}),
+        ...(input.descriptionMode !== undefined
+            ? { descriptionMode: input.descriptionMode }
+            : {}),
+        ...(input.descriptionCustom !== undefined
+            ? { descriptionCustom: input.descriptionCustom }
+            : {}),
+        ...(input.status !== undefined ? { status: input.status } : {}),
+        ...(input.priority !== undefined
+            ? { priority: input.priority }
+            : {}),
+        ...(input.assignedToMode !== undefined
+            ? { assignedToMode: input.assignedToMode }
+            : {}),
+        ...(input.assignedToCustom !== undefined
+            ? { assignedToCustom: input.assignedToCustom }
+            : {}),
+        ...(input.targetVersionMode !== undefined
+            ? { targetVersionMode: input.targetVersionMode }
+            : {}),
+        ...(input.targetVersionCustom !== undefined
+            ? { targetVersionCustom: input.targetVersionCustom }
+            : {}),
+        ...(input.parentTaskMode !== undefined
+            ? { parentTaskMode: input.parentTaskMode }
+            : {}),
+        ...(input.parentTaskCustom !== undefined
+            ? { parentTaskCustom: input.parentTaskCustom }
+            : {}),
+        ...(input.startDateMode !== undefined
+            ? { startDateMode: input.startDateMode }
+            : {}),
+        ...(input.startDateCustom !== undefined
+            ? { startDateCustom: input.startDateCustom }
+            : {}),
+        ...(input.dueDateMode !== undefined
+            ? { dueDateMode: input.dueDateMode }
+            : {}),
+        ...(input.dueDateCustom !== undefined
+            ? { dueDateCustom: input.dueDateCustom }
+            : {}),
+        ...(input.estimatedTimeMode !== undefined
+            ? { estimatedTimeMode: input.estimatedTimeMode }
+            : {}),
+        ...(input.estimatedTimeCustom !== undefined
+            ? { estimatedTimeCustom: input.estimatedTimeCustom }
+            : {}),
+        ...(input.qaStatusMode !== undefined
+            ? { qaStatusMode: input.qaStatusMode }
+            : {}),
+        ...(input.qaStatusCustom !== undefined
+            ? { qaStatusCustom: input.qaStatusCustom }
+            : {}),
+        ...(input.gitLinkMode !== undefined
+            ? { gitLinkMode: input.gitLinkMode }
+            : {}),
+        ...(input.gitLinkCustom !== undefined
+            ? { gitLinkCustom: input.gitLinkCustom }
+            : {}),
+        ...(input.gitLink1Mode !== undefined
+            ? { gitLink1Mode: input.gitLink1Mode }
+            : {}),
+        ...(input.gitLink1Custom !== undefined
+            ? { gitLink1Custom: input.gitLink1Custom }
+            : {}),
+        ...(input.gitLink2Mode !== undefined
+            ? { gitLink2Mode: input.gitLink2Mode }
+            : {}),
+        ...(input.gitLink2Custom !== undefined
+            ? { gitLink2Custom: input.gitLink2Custom }
+            : {}),
+        ...(input.expectedTimeMode !== undefined
+            ? { expectedTimeMode: input.expectedTimeMode }
+            : {}),
+        ...(input.expectedTimeCustom !== undefined
+            ? { expectedTimeCustom: input.expectedTimeCustom }
+            : {}),
+        ...(input.prLinkMode !== undefined
+            ? { prLinkMode: input.prLinkMode }
+            : {}),
+        ...(input.prLinkCustom !== undefined
+            ? { prLinkCustom: input.prLinkCustom }
+            : {}),
+        ...(input.storyPointsMode !== undefined
+            ? { storyPointsMode: input.storyPointsMode }
+            : {}),
+        ...(input.storyPointsCustom !== undefined
+            ? { storyPointsCustom: input.storyPointsCustom }
+            : {}),
+        ...(input.confirmSave !== undefined
+            ? { confirmSave: input.confirmSave }
+            : {}),
+    })));
+    server.registerTool("redmine_agent_get_all_users", {
+        description: "List assignable users from projects the API user belongs to (via project memberships). Use assigneeOptions to match spreadsheet Assigned To before batch create. Optional projectId limits to one project. Returns source, projects[], users (id, name, label, roles, projectIds), assigneeOptions.",
+        inputSchema: {
+            projectId: z
+                .number()
+                .int()
+                .optional()
+                .describe("Limit to members of this project (must be in your memberships)"),
+            status: z
+                .enum(["active", "all"])
+                .optional()
+                .describe("Legacy field; membership listing does not use global /users."),
+        },
+    }, async (input) => workflowToMcpContent(await getAllUsersWorkflow({
+        ...(input.projectId !== undefined ? { projectId: input.projectId } : {}),
+        ...(input.status !== undefined ? { status: input.status } : {}),
+    })));
+    server.registerTool("redmine_agent_sheet_to_csv", {
+        description: "Convert Google Sheets MCP get_sheet_data output to csvContent for batch create. Pass sheetsPayload from get_sheet_data (or rows[][]). Returns csvContent, optional csvPath cache, sheetSource (for agent write-back via Google Sheets MCP), and header preview. Does not call Google APIs — fetch the sheet via Google Sheets MCP first.",
+        inputSchema: {
+            sheetsPayload: z
+                .unknown()
+                .optional()
+                .describe("Full get_sheet_data result (object or JSON string)"),
+            rows: z
+                .array(z.array(z.string()))
+                .optional()
+                .describe("Raw grid when not passing sheetsPayload"),
+            spreadsheetId: z
+                .string()
+                .optional()
+                .describe("Spreadsheet id (override or required with rows-only)"),
+            sheet: z
+                .string()
+                .optional()
+                .describe("Tab name (override or from sheetsPayload range)"),
+            writeCache: z
+                .boolean()
+                .optional()
+                .describe("Write .cursor/cache/last-sheet.csv (default true)"),
+        },
+    }, async (input) => workflowToMcpContent(await sheetToCsvWorkflow({
+        ...(input.sheetsPayload !== undefined
+            ? { sheetsPayload: input.sheetsPayload }
+            : {}),
+        ...(input.rows !== undefined ? { rows: input.rows } : {}),
+        ...(input.spreadsheetId !== undefined
+            ? { spreadsheetId: input.spreadsheetId }
+            : {}),
+        ...(input.sheet !== undefined ? { sheet: input.sheet } : {}),
+        ...(input.writeCache !== undefined
+            ? { writeCache: input.writeCache }
+            : {}),
+    })));
+    server.registerTool("redmine_agent_batch_create_issues", {
+        description: "Feature → User Stories → Tasks from csvContent (from redmine_agent_sheet_to_csv) or csvPath. First call: pick_project (no default project). Then pick_target_version → map_columns → confirm_mapping → fix_assignees → preview_gate → proceed. Pass sheetSource from sheet_to_csv when batch started from Google Sheets (agent uses it for write-back hints only). User must confirm before previewAction proceed.",
+        inputSchema: {
+            csvPath: z
+                .string()
+                .optional()
+                .describe("Workspace path to CSV (e.g. batch_creation.csv)"),
+            csvContent: z.string().optional().describe("Raw CSV text if not using csvPath"),
+            project: z
+                .string()
+                .optional()
+                .describe("Project id or 'id — name' from getProjects. Required before column mapping — first batch call returns pick_project if omitted."),
+            status: z.string().optional().describe('Default "New"'),
+            priority: z.string().optional().describe('Default "Normal"'),
+            skipNodeIds: z
+                .array(z.string())
+                .optional()
+                .describe('nodeIds to skip (e.g. "row-12-subtask")'),
+            rowFixes: z
+                .record(z.string(), z.object({
+                subject: z.string().optional(),
+                assignedTo: z.string().optional(),
+                project: z.string().optional(),
+                targetVersion: z.string().optional(),
+            }))
+                .optional()
+                .describe("Per-row overrides keyed by nodeId"),
+            confirmSave: z.enum(["yes", "no"]).optional(),
+            previewAction: z
+                .enum(["show_preview", "proceed", "cancel"])
+                .optional()
+                .describe("After preview_gate: show_preview = full line list; proceed = post; cancel = abort"),
+            sheetSource: z
+                .object({
+                spreadsheetId: z.string(),
+                sheetTitle: z.string(),
+            })
+                .optional()
+                .describe("From redmine_agent_sheet_to_csv — metadata for agent sheet write-back (Google Sheets MCP); not written by this tool"),
+            existingNodeIds: z
+                .record(z.string(), z.number())
+                .optional()
+                .describe("nodeId → Redmine issue id from a prior upload (feature-root, row-N-userStory); links parents without duplicating"),
+            assigneeNameFixes: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Invalid sheet assignee label → member label (e.g. "Muzamil khan" → "1590 — Name"), "Leave unassigned" to create without assignee, or "Skip this row" to skip all rows with that label'),
+            priorityNameFixes: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Invalid sheet priority label → priority from priorityOptions (e.g. "Highest" → "1 — Immediate")'),
+            trackerNameFixes: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Invalid sheet Type label → tracker from trackerOptions (e.g. "CR" → "5 — Change Request")'),
+            statusNameFixes: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Invalid sheet Status label → status from statusOptions (e.g. "On Hold" → "19 — Waiting for Support")'),
+            missingTargetVersionFix: z
+                .string()
+                .optional()
+                .describe('Default target version for stories without Target Version in sheet: project version "id — name", "Create: <name>" (new version; name from AskQuestion Other), or "Skip target version". Required after project, before column mapping — returns pick_target_version if omitted.'),
+            sheetParseMode: z
+                .enum(["structure_only"])
+                .optional()
+                .describe("structure_only: raw rows + fieldSchema for agent column mapping; then retry with columnMapping. Omitted without columnMapping also returns map_columns."),
+            columnMapping: z
+                .object({
+                headerRowIndex: z
+                    .number()
+                    .int()
+                    .describe("0-based row index of header line in sheet"),
+                columns: z
+                    .record(z.string(), z.union([z.string(), z.number()]))
+                    .describe("Role → header label or 0-based column index (userStory, subtask, description, hours, targetVersion, assignedTo, comments, redmineId, …)"),
+            })
+                .optional()
+                .describe("Agent-provided mapping after reading detectedHeaders (required: userStory + subtask)"),
+            confirmMappingAction: z
+                .enum(["proceed"])
+                .optional()
+                .describe('After confirm_mapping: "proceed" to parse sheet and continue to preview_gate'),
+        },
+    }, async (input) => {
+        const batchInput = {};
+        if (input.sheetSource !== undefined) {
+            batchInput.sheetSource = input.sheetSource;
+        }
+        if (input.csvPath !== undefined)
+            batchInput.csvPath = input.csvPath;
+        if (input.csvContent !== undefined)
+            batchInput.csvContent = input.csvContent;
+        if (input.project !== undefined)
+            batchInput.project = input.project;
+        if (input.status !== undefined)
+            batchInput.status = input.status;
+        if (input.priority !== undefined)
+            batchInput.priority = input.priority;
+        if (input.skipNodeIds !== undefined)
+            batchInput.skipNodeIds = input.skipNodeIds;
+        if (input.confirmSave !== undefined)
+            batchInput.confirmSave = input.confirmSave;
+        if (input.previewAction !== undefined) {
+            batchInput.previewAction = input.previewAction;
+        }
+        if (input.existingNodeIds !== undefined) {
+            batchInput.existingNodeIds = input.existingNodeIds;
+        }
+        if (input.assigneeNameFixes !== undefined) {
+            batchInput.assigneeNameFixes = input.assigneeNameFixes;
+        }
+        if (input.priorityNameFixes !== undefined) {
+            batchInput.priorityNameFixes = input.priorityNameFixes;
+        }
+        if (input.trackerNameFixes !== undefined) {
+            batchInput.trackerNameFixes = input.trackerNameFixes;
+        }
+        if (input.statusNameFixes !== undefined) {
+            batchInput.statusNameFixes = input.statusNameFixes;
+        }
+        if (input.missingTargetVersionFix !== undefined) {
+            batchInput.missingTargetVersionFix = input.missingTargetVersionFix;
+        }
+        if (input.sheetParseMode !== undefined) {
+            batchInput.sheetParseMode = input.sheetParseMode;
+        }
+        if (input.columnMapping !== undefined) {
+            batchInput.columnMapping = input.columnMapping;
+        }
+        if (input.confirmMappingAction !== undefined) {
+            batchInput.confirmMappingAction = input.confirmMappingAction;
+        }
+        if (input.rowFixes !== undefined) {
+            batchInput.rowFixes = {};
+            for (const [nodeId, fix] of Object.entries(input.rowFixes)) {
+                const entry = {};
+                if (fix.subject !== undefined)
+                    entry.subject = fix.subject;
+                if (fix.assignedTo !== undefined)
+                    entry.assignedTo = fix.assignedTo;
+                if (fix.project !== undefined)
+                    entry.project = fix.project;
+                if (fix.targetVersion !== undefined) {
+                    entry.targetVersion = fix.targetVersion;
+                }
+                batchInput.rowFixes[nodeId] = entry;
+            }
+        }
+        return workflowToMcpContent(await batchCreateIssuesWorkflow(batchInput));
+    });
+    server.registerTool("redmine_agent_bulk_update_issues", {
+        description: "Bulk-update Redmine task description and status from a Google Sheet/CSV or updates[] list. Match by Ticket:#id (preferred) or exact task title (subtask/Tasks column). Steps: pick_project → map_columns → confirm_mapping → preview_gate → previewAction proceed. User must confirm before apply.",
+        inputSchema: {
+            csvPath: z
+                .string()
+                .optional()
+                .describe("Workspace path to CSV from redmine_agent_sheet_to_csv"),
+            csvContent: z.string().optional().describe("Raw CSV text"),
+            project: z
+                .string()
+                .optional()
+                .describe("Project id or 'id — name'. First call returns pick_project if omitted."),
+            columnMapping: z
+                .object({
+                headerRowIndex: z.number().int(),
+                columns: z.record(z.string(), z.union([z.string(), z.number()])),
+            })
+                .optional()
+                .describe("From map_columns suggestedColumnMapping"),
+            confirmMappingAction: z
+                .enum(["proceed"])
+                .optional()
+                .describe("After confirm_mapping"),
+            updates: z
+                .array(z.object({
+                subject: z
+                    .string()
+                    .describe("Task title to match when issueId omitted"),
+                issueId: z.number().int().optional(),
+                description: z.string().optional(),
+                status: z.string().optional().describe(statusDescribe),
+            }))
+                .optional()
+                .describe("Direct updates without CSV — match by issueId or exact subject in project"),
+            statusNameFixes: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Sheet status label → "id — name" from statusOptions'),
+            previewAction: z
+                .enum(["show_preview", "proceed", "cancel"])
+                .optional(),
+            confirmSave: z.enum(["yes", "no"]).optional(),
+        },
+    }, async (input) => {
+        const bulkInput = {};
+        if (input.csvPath !== undefined)
+            bulkInput.csvPath = input.csvPath;
+        if (input.csvContent !== undefined)
+            bulkInput.csvContent = input.csvContent;
+        if (input.project !== undefined)
+            bulkInput.project = input.project;
+        if (input.confirmMappingAction !== undefined) {
+            bulkInput.confirmMappingAction = input.confirmMappingAction;
+        }
+        if (input.updates !== undefined) {
+            bulkInput.updates = input.updates.map((u) => ({
+                subject: u.subject,
+                ...(u.issueId !== undefined ? { issueId: u.issueId } : {}),
+                ...(u.description !== undefined
+                    ? { description: u.description }
+                    : {}),
+                ...(u.status !== undefined ? { status: u.status } : {}),
+            }));
+        }
+        if (input.statusNameFixes !== undefined) {
+            bulkInput.statusNameFixes = input.statusNameFixes;
+        }
+        if (input.previewAction !== undefined) {
+            bulkInput.previewAction = input.previewAction;
+        }
+        if (input.confirmSave !== undefined)
+            bulkInput.confirmSave = input.confirmSave;
+        if (input.columnMapping !== undefined) {
+            bulkInput.columnMapping = {
+                headerRowIndex: input.columnMapping.headerRowIndex,
+                columns: input.columnMapping.columns,
+            };
+        }
+        return workflowToMcpContent(await bulkUpdateIssuesWorkflow(bulkInput));
+    });
+    server.registerTool("redmine_agent_list_permissions", {
+        description: "List effective Redmine permissions for the API key’s current user (union across their role permissions). Optionally filter by a single project ID.",
+        inputSchema: {
+            projectId: z.number().int().optional().describe("Filter by project ID"),
+        },
+    }, async (input) => {
+        const current = await getCurrentUserWithMemberships();
+        const user = current.user ?? current;
+        const memberships = (user.memberships ?? []);
+        const filteredMemberships = input?.projectId
+            ? memberships.filter((m) => m.project?.id === input.projectId)
+            : memberships;
+        const roleIds = new Set();
+        for (const m of filteredMemberships) {
+            for (const r of m.roles ?? [])
+                roleIds.add(r.id);
+        }
+        const permissionsUnion = new Set();
+        const rolesExpanded = [];
+        for (const roleId of [...roleIds].sort((a, b) => a - b)) {
+            try {
+                const role = (await getRolePermissions(roleId));
+                const permissions = (Array.isArray(role.permissions)
+                    ? role.permissions
+                    : []);
+                permissions.forEach((p) => permissionsUnion.add(p));
+                rolesExpanded.push({
+                    roleId,
+                    roleName: role.name ?? null,
+                    projectNames: [
+                        ...new Set(filteredMemberships
+                            .filter((m) => (m.roles ?? []).some((r) => r.id === roleId))
+                            .map((m) => m.project?.name)
+                            .filter(Boolean)),
+                    ],
+                    permissions,
+                });
+            }
+            catch (e) {
+                const status = e?.response?.status;
+                rolesExpanded.push({
+                    roleId,
+                    roleName: null,
+                    projectNames: [
+                        ...new Set(filteredMemberships
+                            .filter((m) => (m.roles ?? []).some((r) => r.id === roleId))
+                            .map((m) => m.project?.name)
+                            .filter(Boolean)),
+                    ],
+                    permissions: [],
+                    fetchError: status ? `HTTP ${status}` : e.message,
+                });
+            }
+        }
+        return workflowToMcpContent({
+            success: true,
+            data: {
+                user: {
+                    id: user.id,
+                    login: user.login,
+                    name: user.name ?? user.firstname,
+                },
+                memberships: filteredMemberships.map((m) => ({
+                    project: m.project ?? null,
+                    roles: (m.roles ?? []).map((r) => ({ id: r.id, name: r.name })),
+                })),
+                permissions: [...permissionsUnion].sort(),
+                permissionsCount: permissionsUnion.size,
+                rolesExpanded,
+            },
+        });
+    });
+    server.registerTool("redmine_agent_log_time", {
+        description: "Batch log time: dates → dateIssues → pairHours → pairActivities (from config cache) → pairComments → preview → confirmSave=yes. Activity options are preloaded at MCP connect; Step 4 requires activityBatchId from prior response.",
+        inputSchema: {
+            promptHint: z
+                .string()
+                .optional()
+                .describe("User message text; if it mentions 'today', date step is skipped"),
+            dates: z
+                .array(z.string())
+                .optional()
+                .describe("Step 1 — Today | Multiple | Other, or YYYY-MM-DD list"),
+            spentOn: z
+                .string()
+                .optional()
+                .describe("Custom date YYYY-MM-DD when Other was chosen"),
+            pendingDates: z.array(z.string()).optional(),
+            activeDate: z.string().optional(),
+            dateIssues: z
+                .record(z.string(), z.union([
+                z.array(z.number().int().positive()),
+                z.string(),
+            ]))
+                .optional()
+                .describe("Step 2 batch — issue IDs per date (number[] or comma-separated string)"),
+            pendingIssueIds: z.array(z.number().int().positive()).optional(),
+            activeIssueId: z.number().int().positive().optional(),
+            issueIds: z
+                .array(z.number().int().positive())
+                .optional()
+                .describe("Legacy — fills all dates if dateIssues omitted (single date only)"),
+            pairInclude: z
+                .enum(["yes", "no"])
+                .optional()
+                .describe("Legacy single pair; prefer pairIncludes"),
+            pairIncludes: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Step 3 batch — all yes/no keyed by "YYYY-MM-DD:issueId"'),
+            pairHours: z
+                .record(z.string(), z.union([z.number(), z.string()]))
+                .optional()
+                .describe("Step 3 batch — hours per included pair key"),
+            pairActivities: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Step 4 batch — activity per pair key: "default" or "id — name". Requires activityBatchId from prior Step 4 response.'),
+            activityBatchId: z
+                .string()
+                .optional()
+                .describe("Pass back from data.activityBatchId after user answers Step 4 activity AskQuestion (mandatory before pairActivities is accepted)"),
+            pairComments: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe('Step 5 batch — "default" or custom text per pair key'),
+            issueSubjects: z
+                .record(z.string(), z.string())
+                .optional()
+                .describe("issueId → subject; pass back from data for question labels"),
+            issueOptions: z
+                .array(z.object({
+                issueId: z.number().int().positive(),
+                subject: z.string().optional(),
+                label: z.string().optional(),
+            }))
+                .optional(),
+            skippedPairs: z
+                .array(z.string())
+                .optional()
+                .describe('Skipped pair keys "YYYY-MM-DD:issueId"'),
+            issueId: z.number().int().positive().optional(),
+            hours: z.number().positive().optional().describe("Legacy single pair hours"),
+            commentChoice: z.enum(["default", "custom"]).optional(),
+            comments: z.string().optional(),
+            entries: z
+                .array(z.object({
+                issueId: z.number().int().positive(),
+                hours: z.number().positive(),
+                spentOn: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+                comments: z.string(),
+                activityId: z.number().int().positive().optional(),
+            }))
+                .optional(),
+            confirmSave: z.enum(["yes", "no"]).optional(),
+        },
+    }, async (input) => workflowToMcpContent(await logTimeWorkflow({
+        ...(input.promptHint !== undefined
+            ? { promptHint: input.promptHint }
+            : {}),
+        ...(input.dates !== undefined ? { dates: input.dates } : {}),
+        ...(input.spentOn !== undefined
+            ? { spentOn: input.spentOn }
+            : {}),
+        ...(input.pendingDates !== undefined
+            ? { pendingDates: input.pendingDates }
+            : {}),
+        ...(input.activeDate !== undefined
+            ? { activeDate: input.activeDate }
+            : {}),
+        ...(input.dateIssues !== undefined
+            ? {
+                // Accept string/number[] in MCP schema; workflow normalizes this shape.
+                dateIssues: input.dateIssues,
+            }
+            : {}),
+        ...(input.pendingIssueIds !== undefined
+            ? { pendingIssueIds: input.pendingIssueIds }
+            : {}),
+        ...(input.activeIssueId !== undefined
+            ? { activeIssueId: input.activeIssueId }
+            : {}),
+        ...(input.issueIds !== undefined
+            ? { issueIds: input.issueIds }
+            : {}),
+        ...(input.issueId !== undefined
+            ? { issueId: input.issueId }
+            : {}),
+        ...(input.hours !== undefined ? { hours: input.hours } : {}),
+        ...(input.pairInclude !== undefined
+            ? { pairInclude: input.pairInclude }
+            : {}),
+        ...(input.pairIncludes !== undefined
+            ? { pairIncludes: input.pairIncludes }
+            : {}),
+        ...(input.pairHours !== undefined
+            ? { pairHours: input.pairHours }
+            : {}),
+        ...(input.pairActivities !== undefined
+            ? { pairActivities: input.pairActivities }
+            : {}),
+        ...(input.activityBatchId !== undefined
+            ? { activityBatchId: input.activityBatchId }
+            : {}),
+        ...(input.pairComments !== undefined
+            ? { pairComments: input.pairComments }
+            : {}),
+        ...(input.issueSubjects !== undefined
+            ? { issueSubjects: input.issueSubjects }
+            : {}),
+        ...(input.issueOptions !== undefined
+            ? { issueOptions: input.issueOptions }
+            : {}),
+        ...(input.skippedPairs !== undefined
+            ? { skippedPairs: input.skippedPairs }
+            : {}),
+        ...(input.commentChoice !== undefined
+            ? { commentChoice: input.commentChoice }
+            : {}),
+        ...(input.comments !== undefined
+            ? { comments: input.comments }
+            : {}),
+        ...(input.entries !== undefined
+            ? { entries: input.entries }
+            : {}),
+        ...(input.confirmSave !== undefined
+            ? { confirmSave: input.confirmSave }
+            : {}),
+    })));
+}
+function createMcpServer(config) {
+    const server = new McpServer({
+        name: "redmine-agent",
+        version: "3.9.0",
+    }, {
+        instructions: `${BASE_MCP_INSTRUCTIONS}\n\n${formatConfigForInstructions(config)}`,
+    });
+    registerTools(server, config);
+    return server;
+}
 async function main() {
+    const config = await loadRedmineConfig();
+    const server = createMcpServer(config);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }