@vitalyostanin/youtrack-mcp 0.2.0

package/dist/src/tools/project-tools.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const projectLookupArgs = {
+    shortName: z.string().min(1).describe("Project short name"),
+};
+const projectLookupSchema = z.object(projectLookupArgs);
+export function registerProjectTools(server, client) {
+    server.tool("projects_list", "List all YouTrack projects. Note: Returns predefined fields only - id, shortName, name.", {}, async () => {
+        try {
+            const projects = await client.listProjects();
+            const response = toolSuccess(projects);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("project_get", "Get YouTrack project by short name. Note: Returns predefined fields only - id, shortName, name.", projectLookupArgs, async (rawInput) => {
+        try {
+            const payload = projectLookupSchema.parse(rawInput);
+            const project = await client.getProjectByShortName(payload.shortName);
+            if (!project) {
+                throw new Error(`Project with short name '${payload.shortName}' not found`);
+            }
+            const response = toolSuccess({ project });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=project-tools.js.map

package/dist/src/tools/service-info.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { YoutrackClient } from "../youtrack-client.js";
+export declare function registerServiceInfoTool(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=service-info.d.ts.map

package/dist/src/tools/service-info.js

@@ -0,0 +1,61 @@
+import { ZodError } from "zod";
+import { loadConfig, enrichConfigWithRedaction } from "../config.js";
+export function registerServiceInfoTool(server, client) {
+    server.tool("service_info", "Get YouTrack integration status and environment configuration", async () => {
+        try {
+            const config = loadConfig();
+            const currentUser = await client.getCurrentUser();
+            const payload = {
+                service: {
+                    name: "youtrack-mcp",
+                    version: "0.1.0",
+                },
+                configuration: enrichConfigWithRedaction(config),
+            };
+            const result = {
+                content: [],
+                structuredContent: {
+                    ...payload,
+                    currentUser,
+                },
+            };
+            return result;
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                const result = {
+                    content: [],
+                    isError: true,
+                    structuredContent: {
+                        name: "ValidationError",
+                        message: "Invalid configuration",
+                        details: error.flatten(),
+                    },
+                };
+                return result;
+            }
+            if (error instanceof Error) {
+                const result = {
+                    content: [],
+                    isError: true,
+                    structuredContent: {
+                        name: error.name,
+                        message: error.message,
+                    },
+                };
+                return result;
+            }
+            const result = {
+                content: [],
+                isError: true,
+                structuredContent: {
+                    name: "UnknownError",
+                    message: "An unknown error occurred",
+                    details: error,
+                },
+            };
+            return result;
+        }
+    });
+}
+//# sourceMappingURL=service-info.js.map

package/dist/src/tools/user-tools.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { YoutrackClient } from "../youtrack-client.js";
+export declare function registerUserTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=user-tools.d.ts.map

package/dist/src/tools/user-tools.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const userLookupArgs = {
+    login: z.string().min(1).describe("User login"),
+};
+const userLookupSchema = z.object(userLookupArgs);
+export function registerUserTools(server, client) {
+    server.tool("users_list", "List all YouTrack users. Note: Returns predefined fields only - id, login, name, fullName, email.", {}, async () => {
+        try {
+            const users = await client.listUsers();
+            const response = toolSuccess(users);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("user_get", "Get YouTrack user by login. Note: Returns predefined fields only - id, login, name, fullName, email.", userLookupArgs, async (rawInput) => {
+        try {
+            const payload = userLookupSchema.parse(rawInput);
+            const user = await client.getUserByLogin(payload.login);
+            if (!user) {
+                throw new Error(`User with login '${payload.login}' not found`);
+            }
+            const response = toolSuccess({ user });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("user_current", "Get current authenticated user. Note: Returns predefined fields only - id, login, name, fullName, email.", {}, async () => {
+        try {
+            const user = await client.getCurrentUser();
+            const response = toolSuccess({ user });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=user-tools.js.map

package/dist/src/tools/workitem-report-tools.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { YoutrackClient } from "../youtrack-client.js";
+export declare function registerWorkitemReportTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=workitem-report-tools.d.ts.map

package/dist/src/tools/workitem-report-tools.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const sharedDate = z.union([z.string().regex(/\d{4}-\d{2}-\d{2}/), z.number(), z.date()]);
+const reportBaseArgs = {
+    author: z.string().optional().describe("Work item author login"),
+    issueId: z.string().optional().describe("Issue code"),
+    startDate: sharedDate.optional().describe("Period start date"),
+    endDate: sharedDate.optional().describe("Period end date"),
+    expectedDailyMinutes: z.number().int().positive().optional().describe("Daily expected minutes"),
+    excludeWeekends: z.boolean().optional().describe("Exclude weekends"),
+    excludeHolidays: z.boolean().optional().describe("Exclude holidays"),
+    holidays: z.array(sharedDate).optional().describe("List of holiday dates"),
+    preHolidays: z.array(sharedDate).optional().describe("List of pre-holiday dates"),
+    allUsers: z.boolean().optional().describe("Include work items for all users"),
+};
+const reportArgsSchema = z.object(reportBaseArgs);
+const reportUsersArgsSchema = z.object({
+    users: z.array(z.string().min(1)).min(1).describe("User logins"),
+    ...reportBaseArgs,
+});
+export function registerWorkitemReportTools(server, client) {
+    server.tool("workitems_report_summary", "Summary report for work items in period. Note: Work items in report include predefined fields only - id, date, duration (minutes, presentation), text, description, issue (id, idReadable), author (id, login, name, email).", reportBaseArgs, async (rawInput) => {
+        try {
+            const payload = reportArgsSchema.parse(rawInput);
+            const report = await client.generateWorkItemReport(payload);
+            const response = toolSuccess({ report });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitems_report_invalid", "List of days with deviation from expected. Note: Work items in report include predefined fields only - id, date, duration (minutes, presentation), text, description, issue (id, idReadable), author (id, login, name, email).", reportBaseArgs, async (rawInput) => {
+        try {
+            const payload = reportArgsSchema.parse(rawInput);
+            const invalidDays = await client.generateInvalidWorkItemReport(payload);
+            const response = toolSuccess({ invalidDays });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitems_report_users", "Work items report for list of users. Note: Work items in report include predefined fields only - id, date, duration (minutes, presentation), text, description, issue (id, idReadable), author (id, login, name, email).", {
+        users: z.array(z.string().min(1)).min(1).describe("User logins"),
+        ...reportBaseArgs,
+    }, async (rawInput) => {
+        try {
+            const payload = reportUsersArgsSchema.parse(rawInput);
+            const report = await client.generateUsersWorkItemReports(payload.users, payload);
+            const response = toolSuccess(report);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=workitem-report-tools.js.map

package/dist/src/tools/workitem-tools.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { YoutrackClient } from "../youtrack-client.js";
+export declare function registerWorkitemTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=workitem-tools.d.ts.map

package/dist/src/tools/workitem-tools.js

@@ -0,0 +1,247 @@
+import { z } from "zod";
+import { mapWorkItem, mapWorkItems } from "../utils/mappers.js";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const isoDate = z
+    .string()
+    .regex(/\d{4}-\d{2}-\d{2}/)
+    .describe("Date in YYYY-MM-DD format");
+const dateInput = z.union([isoDate, z.number(), z.date()]);
+const baseFilterArgs = {
+    issueId: z.string().optional().describe("Issue code (e.g., PROJ-123)"),
+    author: z.string().optional().describe("Work item author login"),
+    startDate: dateInput.optional().describe("Period start date"),
+    endDate: dateInput.optional().describe("Period end date"),
+    allUsers: z.boolean().optional().describe("Get work items for all users"),
+};
+const workItemsListSchema = z.object(baseFilterArgs);
+const workItemsForUsersArgs = {
+    ...baseFilterArgs,
+    users: z.array(z.string().min(1)).min(1).describe("User logins"),
+};
+const workItemsUsersSchema = z.object(workItemsForUsersArgs);
+const workItemCreateArgs = {
+    issueId: z.string().min(1).describe("Issue ID"),
+    date: dateInput.describe("Date"),
+    minutes: z.number().int().positive().describe("Minutes"),
+    summary: z.string().optional().describe("Brief text"),
+    description: z.string().optional().describe("Description"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+};
+const workItemCreateSchema = z.object(workItemCreateArgs);
+const workItemIdempotentArgs = {
+    issueId: z.string().min(1).describe("Issue ID"),
+    date: dateInput.describe("Date"),
+    minutes: z.number().int().positive().describe("Minutes"),
+    description: z.string().min(1).describe("Text to search for existing work item"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+};
+const workItemIdempotentSchema = z.object(workItemIdempotentArgs);
+const workItemUpdateArgs = {
+    issueId: z.string().min(1).describe("Issue ID"),
+    workItemId: z.string().min(1).describe("Work item ID"),
+    date: dateInput.optional().describe("New date"),
+    minutes: z.number().int().positive().optional().describe("New minutes"),
+    summary: z.string().optional().describe("New text"),
+    description: z.string().optional().describe("New description"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+};
+const workItemUpdateSchema = z.object(workItemUpdateArgs);
+const workItemDeleteArgs = {
+    issueId: z.string().min(1).describe("Issue ID"),
+    workItemId: z.string().min(1).describe("Work item ID"),
+};
+const workItemDeleteSchema = z.object(workItemDeleteArgs);
+const workItemsPeriodArgs = {
+    issueId: z.string().min(1).describe("Issue ID"),
+    startDate: dateInput.describe("Period start date"),
+    endDate: dateInput.describe("Period end date"),
+    minutes: z.number().int().positive().describe("Minutes per day"),
+    summary: z.string().optional().describe("Brief text"),
+    description: z.string().optional().describe("Description"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+    excludeWeekends: z.boolean().optional().describe("Exclude weekends"),
+    excludeHolidays: z.boolean().optional().describe("Exclude holidays"),
+    holidays: z.array(dateInput).optional().describe("Holidays"),
+    preHolidays: z.array(dateInput).optional().describe("Pre-holiday days"),
+};
+const workItemsPeriodSchema = z.object(workItemsPeriodArgs);
+const workItemsReportArgs = {
+    author: z.string().optional().describe("Author login"),
+    issueId: z.string().optional().describe("Issue code"),
+    startDate: dateInput.optional().describe("Period start date"),
+    endDate: dateInput.optional().describe("Period end date"),
+    expectedDailyMinutes: z.number().int().positive().optional().describe("Expected minutes"),
+    excludeWeekends: z.boolean().optional().describe("Exclude weekends"),
+    excludeHolidays: z.boolean().optional().describe("Exclude holidays"),
+    holidays: z.array(dateInput).optional().describe("Holidays"),
+    preHolidays: z.array(dateInput).optional().describe("Pre-holiday days"),
+    allUsers: z.boolean().optional().describe("Get report for all users"),
+};
+const workItemsReportSchema = z.object(workItemsReportArgs);
+const workItemsRecentArgs = {
+    users: z.array(z.string().min(1)).optional().describe("User logins (defaults to current user)"),
+    limit: z.number().int().positive().max(200).optional().describe("Maximum number of items (default 50)"),
+};
+const workItemsRecentSchema = z.object(workItemsRecentArgs);
+export function registerWorkitemTools(server, client) {
+    server.tool("workitems_list", "Get list of work items. Note: Returns predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", baseFilterArgs, async (rawInput) => {
+        try {
+            const payload = workItemsListSchema.parse(rawInput);
+            const items = await client.listWorkItems(payload);
+            const response = toolSuccess({ items: mapWorkItems(items) });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitems_all_users", "Get work items for all users. Note: Returns predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", baseFilterArgs, async (rawInput) => {
+        try {
+            const payload = workItemsListSchema.parse(rawInput);
+            const items = await client.listAllUsersWorkItems(payload);
+            const response = toolSuccess({ items: mapWorkItems(items) });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitems_for_users", "Get work items for selected users. Note: Returns predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", workItemsForUsersArgs, async (rawInput) => {
+        try {
+            const payload = workItemsUsersSchema.parse(rawInput);
+            const items = await client.getWorkItemsForUsers(payload.users, payload);
+            const response = toolSuccess({ items: mapWorkItems(items), users: payload.users });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitem_create", "Create work item record. Note: Response includes predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", workItemCreateArgs, async (rawInput) => {
+        try {
+            const payload = workItemCreateSchema.parse(rawInput);
+            const item = await client.createWorkItemMapped({
+                issueId: payload.issueId,
+                date: payload.date,
+                minutes: payload.minutes,
+                summary: payload.summary,
+                description: payload.description,
+                usesMarkdown: payload.usesMarkdown,
+            });
+            const response = toolSuccess({ item });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitem_create_idempotent", "Create work item record if similar one does not exist. Note: Response includes predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", workItemIdempotentArgs, async (rawInput) => {
+        try {
+            const payload = workItemIdempotentSchema.parse(rawInput);
+            const item = await client.createWorkItemIdempotent({
+                issueId: payload.issueId,
+                date: payload.date,
+                minutes: payload.minutes,
+                description: payload.description,
+                usesMarkdown: payload.usesMarkdown,
+            });
+            const response = toolSuccess({ created: item !== null, item });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitem_update", "Update work item record. Note: Response includes predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", workItemUpdateArgs, async (rawInput) => {
+        try {
+            const payload = workItemUpdateSchema.parse(rawInput);
+            if (payload.date === undefined &&
+                payload.minutes === undefined &&
+                payload.summary === undefined &&
+                payload.description === undefined) {
+                throw new Error("At least one field must be provided for update");
+            }
+            const item = await client.updateWorkItem({
+                issueId: payload.issueId,
+                workItemId: payload.workItemId,
+                date: payload.date,
+                minutes: payload.minutes,
+                summary: payload.summary,
+                description: payload.description,
+                usesMarkdown: payload.usesMarkdown,
+            });
+            const response = toolSuccess({ item: mapWorkItem(item) });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitem_delete", "Delete work item record", workItemDeleteArgs, async (rawInput) => {
+        try {
+            const payload = workItemDeleteSchema.parse(rawInput);
+            const result = await client.deleteWorkItem(payload.issueId, payload.workItemId);
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitems_create_period", "Create work items for period. Note: Created work items include predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", workItemsPeriodArgs, async (rawInput) => {
+        try {
+            const payload = workItemsPeriodSchema.parse(rawInput);
+            const result = await client.createWorkItemsForPeriod({
+                issueId: payload.issueId,
+                startDate: payload.startDate,
+                endDate: payload.endDate,
+                minutes: payload.minutes,
+                summary: payload.summary,
+                description: payload.description,
+                usesMarkdown: payload.usesMarkdown,
+                excludeWeekends: payload.excludeWeekends,
+                excludeHolidays: payload.excludeHolidays,
+                holidays: payload.holidays,
+                preHolidays: payload.preHolidays,
+            });
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitems_report", "Generate work items report", workItemsReportArgs, async (rawInput) => {
+        try {
+            const payload = workItemsReportSchema.parse(rawInput);
+            const report = await client.generateWorkItemReport(payload);
+            const response = toolSuccess(report);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("workitems_recent", "Get recent work items sorted by update time descending. Note: Returns predefined fields only - id, date, duration (minutes, presentation), text, textPreview, usesMarkdown, description, issue (id, idReadable), author (id, login, name, email).", workItemsRecentArgs, async (rawInput) => {
+        try {
+            const payload = workItemsRecentSchema.parse(rawInput);
+            const items = await client.listRecentWorkItems(payload);
+            const response = toolSuccess({ items: mapWorkItems(items), count: items.length });
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=workitem-tools.js.map