@vitalyostanin/youtrack-mcp 0.2.0

package/dist/src/config.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+const configSchema = z.object({
+    YOUTRACK_URL: z.string().url(),
+    YOUTRACK_TOKEN: z.string().min(1),
+    YOUTRACK_TIMEZONE: z.string().optional(),
+    YOUTRACK_HOLIDAYS: z.string().optional(),
+    YOUTRACK_PRE_HOLIDAYS: z.string().optional(),
+    YOUTRACK_USER_ALIASES: z.string().optional(),
+});
+export function loadConfig(env = process.env) {
+    const parsed = configSchema.safeParse(env);
+    if (!parsed.success) {
+        const { fieldErrors } = parsed.error.flatten();
+        const missingFields = Object.entries(fieldErrors)
+            .filter(([, issues]) => Array.isArray(issues) && issues.length > 0)
+            .map(([field]) => field);
+        const errorMessage = missingFields.length
+            ? `missing environment variables: ${missingFields.join(", ")}`
+            : "invalid configuration";
+        throw new Error(`YouTrack configuration error: ${errorMessage}`);
+    }
+    return {
+        baseUrl: parsed.data.YOUTRACK_URL,
+        token: parsed.data.YOUTRACK_TOKEN,
+        timezone: parsed.data.YOUTRACK_TIMEZONE ?? "Europe/Moscow",
+        holidays: parsed.data.YOUTRACK_HOLIDAYS
+            ? parseCsvList(parsed.data.YOUTRACK_HOLIDAYS)
+            : undefined,
+        preHolidays: parsed.data.YOUTRACK_PRE_HOLIDAYS
+            ? parseCsvList(parsed.data.YOUTRACK_PRE_HOLIDAYS)
+            : undefined,
+        userAliases: parsed.data.YOUTRACK_USER_ALIASES
+            ? parseAliasMap(parsed.data.YOUTRACK_USER_ALIASES)
+            : undefined,
+    };
+}
+export function enrichConfigWithRedaction(config) {
+    return {
+        baseUrl: config.baseUrl,
+        hasToken: config.token.length > 0,
+        timezone: config.timezone,
+        holidays: config.holidays,
+        preHolidays: config.preHolidays,
+    };
+}
+function parseCsvList(value) {
+    const items = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length);
+    return items;
+}
+function parseAliasMap(value) {
+    const aliasMap = value
+        .split(",")
+        .map((pair) => pair.trim())
+        .filter((pair) => pair.length)
+        .reduce((acc, pair) => {
+        const [alias, login] = pair.split(":").map((part) => part.trim());
+        if (!(alias && login)) {
+            throw new Error("Invalid YOUTRACK_USER_ALIASES format. Expected comma-separated list of alias:login pairs.");
+        }
+        acc[alias] = login;
+        return acc;
+    }, {});
+    return aliasMap;
+}
+//# sourceMappingURL=config.js.map

package/dist/src/server.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare class YoutrackServer {
+    private readonly server;
+    private readonly client;
+    constructor();
+    connect(transport: Parameters<McpServer["connect"]>[0]): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/src/server.js

@@ -0,0 +1,48 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerServiceInfoTool } from "./tools/service-info.js";
+import { registerIssueTools } from "./tools/issue-tools.js";
+import { registerIssueSearchTools } from "./tools/issue-search-tools.js";
+import { registerWorkitemTools } from "./tools/workitem-tools.js";
+import { registerWorkitemReportTools } from "./tools/workitem-report-tools.js";
+import { registerArticleTools } from "./tools/article-tools.js";
+import { registerArticleSearchTools } from "./tools/article-search-tools.js";
+import { registerUserTools } from "./tools/user-tools.js";
+import { registerProjectTools } from "./tools/project-tools.js";
+import { registerAttachmentTools } from "./tools/attachment-tools.js";
+import { YoutrackClient } from "./youtrack-client.js";
+import { loadConfig } from "./config.js";
+import { initializeTimezone } from "./utils/date.js";
+export class YoutrackServer {
+    server;
+    client;
+    constructor() {
+        this.server = new McpServer({
+            name: "youtrack-mcp",
+            version: "0.2.0",
+        }, {
+            capabilities: {
+                tools: {
+                    listChanged: false,
+                },
+                logging: {},
+            },
+        });
+        const config = loadConfig();
+        initializeTimezone(config.timezone);
+        this.client = new YoutrackClient(config);
+        registerServiceInfoTool(this.server, this.client);
+        registerIssueTools(this.server, this.client);
+        registerIssueSearchTools(this.server, this.client);
+        registerWorkitemTools(this.server, this.client);
+        registerWorkitemReportTools(this.server, this.client);
+        registerArticleTools(this.server, this.client);
+        registerArticleSearchTools(this.server, this.client);
+        registerUserTools(this.server, this.client);
+        registerProjectTools(this.server, this.client);
+        registerAttachmentTools(this.server, this.client);
+    }
+    async connect(transport) {
+        await this.server.connect(transport);
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/src/tools/article-search-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 registerArticleSearchTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=article-search-tools.d.ts.map

package/dist/src/tools/article-search-tools.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const articleSearchArgs = {
+    query: z.string().min(2).describe("Search string for summary and content"),
+    projectId: z.string().optional().describe("Filter by project ID"),
+    parentArticleId: z.string().optional().describe("Filter by parent article"),
+    limit: z.number().int().positive().max(200).optional().describe("Maximum number of results"),
+    returnRendered: z.boolean().optional().describe("Return rendered content preview"),
+};
+const articleSearchSchema = z.object(articleSearchArgs);
+export function registerArticleSearchTools(server, client) {
+    server.tool("article_search", "Search articles in knowledge base by text. Note: Returns predefined fields only - id, idReadable, summary, usesMarkdown, contentPreview (when returnRendered is true), parentArticle (id, idReadable), project (id, shortName, name). Content field is not included for performance reasons.", articleSearchArgs, async (rawInput) => {
+        try {
+            const payload = articleSearchSchema.parse(rawInput);
+            const articles = await client.searchArticles({
+                query: payload.query,
+                projectId: payload.projectId,
+                parentArticleId: payload.parentArticleId,
+                limit: payload.limit,
+                returnRendered: payload.returnRendered,
+            });
+            const response = toolSuccess(articles);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=article-search-tools.js.map

package/dist/src/tools/article-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 registerArticleTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=article-tools.d.ts.map

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

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const articleLookupArgs = {
+    articleId: z.string().min(1).describe("Article ID"),
+};
+const articleListArgs = {
+    parentArticleId: z.string().optional().describe("Parent article ID"),
+    projectId: z.string().optional().describe("Project ID"),
+};
+const articleCreateArgs = {
+    summary: z.string().min(1).describe("Article title"),
+    content: z.string().optional().describe("Article content"),
+    parentArticleId: z.string().optional().describe("Parent article ID"),
+    projectId: z.string().optional().describe("Project ID"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+    returnRendered: z.boolean().optional().describe("Return rendered content preview"),
+};
+const articleUpdateArgs = {
+    articleId: z.string().min(1).describe("Article ID"),
+    summary: z.string().optional().describe("New title"),
+    content: z.string().optional().describe("New content"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+    returnRendered: z.boolean().optional().describe("Return rendered content preview"),
+};
+const articleLookupSchema = z.object(articleLookupArgs);
+const articleListSchema = z.object(articleListArgs);
+const articleCreateSchema = z.object(articleCreateArgs);
+const articleUpdateSchema = z.object(articleUpdateArgs);
+export function registerArticleTools(server, client) {
+    server.tool("article_get", "Get YouTrack article by ID. Note: Returns predefined fields only - id, idReadable, summary, content, contentPreview, usesMarkdown, parentArticle (id, idReadable), project (id, shortName, name).", articleLookupArgs, async (rawInput) => {
+        try {
+            const payload = articleLookupSchema.parse(rawInput);
+            const article = await client.getArticle(payload.articleId);
+            const response = toolSuccess(article);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("article_list", "List Knowledge Base articles. Note: Returns predefined fields only - id, idReadable, summary, usesMarkdown, parentArticle (id, idReadable), project (id, shortName, name). Content field is not included for performance reasons.", articleListArgs, async (rawInput) => {
+        try {
+            const payload = articleListSchema.parse(rawInput);
+            const articles = await client.listArticles({
+                parentArticleId: payload.parentArticleId,
+                projectId: payload.projectId,
+            });
+            const response = toolSuccess(articles);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("article_create", "Create article in YouTrack knowledge base. Note: Response includes predefined fields only - id, idReadable, summary, content, contentPreview, usesMarkdown, parentArticle (id, idReadable), project (id, shortName, name).", articleCreateArgs, async (rawInput) => {
+        try {
+            const payload = articleCreateSchema.parse(rawInput);
+            const article = await client.createArticle({
+                summary: payload.summary,
+                content: payload.content,
+                parentArticleId: payload.parentArticleId,
+                projectId: payload.projectId,
+                usesMarkdown: payload.usesMarkdown,
+                returnRendered: payload.returnRendered,
+            });
+            const response = toolSuccess(article);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("article_update", "Update existing article. Note: Response includes predefined fields only - id, idReadable, summary, content, contentPreview, usesMarkdown, parentArticle (id, idReadable), project (id, shortName, name).", articleUpdateArgs, async (rawInput) => {
+        try {
+            const payload = articleUpdateSchema.parse(rawInput);
+            if (payload.summary === undefined && payload.content === undefined) {
+                throw new Error("At least one field must be provided for update");
+            }
+            const article = await client.updateArticle({
+                articleId: payload.articleId,
+                summary: payload.summary,
+                content: payload.content,
+                usesMarkdown: payload.usesMarkdown,
+                returnRendered: payload.returnRendered,
+            });
+            const response = toolSuccess(article);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=article-tools.js.map

package/dist/src/tools/attachment-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 registerAttachmentTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=attachment-tools.d.ts.map

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

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const issueIdArgs = {
+    issueId: z.string().min(1).describe("Issue code (e.g., PROJ-123)"),
+};
+const issueIdSchema = z.object(issueIdArgs);
+const attachmentGetArgs = {
+    ...issueIdArgs,
+    attachmentId: z.string().min(1).describe("Attachment ID"),
+};
+const attachmentGetSchema = z.object(attachmentGetArgs);
+const attachmentUploadArgs = {
+    ...issueIdArgs,
+    filePaths: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(10)
+        .describe("Array of absolute file paths to upload (max 10 files)"),
+    muteUpdateNotifications: z.boolean().optional().describe("If true, do not send update notifications"),
+};
+const attachmentUploadSchema = z.object(attachmentUploadArgs);
+const attachmentDeleteArgs = {
+    ...issueIdArgs,
+    attachmentId: z.string().min(1).describe("Attachment ID to delete"),
+    confirmation: z
+        .boolean()
+        .describe("Must be explicitly set to 'true' to confirm deletion. This is a required safety parameter for destructive operations."),
+};
+const attachmentDeleteSchema = z.object(attachmentDeleteArgs);
+export function registerAttachmentTools(server, client) {
+    server.tool("issue_attachments_list", "Get list of attachments for a YouTrack issue. Returns metadata for all files attached to the issue.", issueIdArgs, async (rawInput) => {
+        try {
+            const payload = issueIdSchema.parse(rawInput);
+            const result = await client.listAttachments(payload.issueId);
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_attachment_get", "Get detailed information about a specific attachment in a YouTrack issue.", attachmentGetArgs, async (rawInput) => {
+        try {
+            const payload = attachmentGetSchema.parse(rawInput);
+            const result = await client.getAttachment(payload.issueId, payload.attachmentId);
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_attachment_download", "Get download information for an attachment. Returns attachment metadata and a signed URL for downloading the file. The signed URL can be used directly without additional authentication.", attachmentGetArgs, async (rawInput) => {
+        try {
+            const payload = attachmentGetSchema.parse(rawInput);
+            const result = await client.getAttachmentDownloadInfo(payload.issueId, payload.attachmentId);
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_attachment_upload", "Upload one or more files to a YouTrack issue. Files must exist on the local filesystem. Note: Can only attach files to existing issues, not during issue creation.", attachmentUploadArgs, async (rawInput) => {
+        try {
+            const payload = attachmentUploadSchema.parse(rawInput);
+            const result = await client.uploadAttachments({
+                issueId: payload.issueId,
+                filePaths: payload.filePaths,
+                muteUpdateNotifications: payload.muteUpdateNotifications,
+            });
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_attachment_delete", "Delete an attachment from a YouTrack issue. IMPORTANT: Requires explicit confirmation via the 'confirmation' parameter to prevent accidental deletion. This is a destructive operation that cannot be undone.", attachmentDeleteArgs, async (rawInput) => {
+        try {
+            const payload = attachmentDeleteSchema.parse(rawInput);
+            const result = await client.deleteAttachment({
+                issueId: payload.issueId,
+                attachmentId: payload.attachmentId,
+                confirmation: payload.confirmation,
+            });
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=attachment-tools.js.map

package/dist/src/tools/issue-search-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 registerIssueSearchTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=issue-search-tools.d.ts.map

package/dist/src/tools/issue-search-tools.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const issueSearchByUserActivityArgs = {
+    userLogins: z
+        .array(z.string().min(1))
+        .min(1)
+        .describe("Array of user logins to search for activity (updater, mentions, reporter, assignee, commenter)"),
+    startDate: z
+        .string()
+        .optional()
+        .describe("Start date for period filter (YYYY-MM-DD format or timestamp)"),
+    endDate: z
+        .string()
+        .optional()
+        .describe("End date for period filter (YYYY-MM-DD format or timestamp)"),
+    dateFilterMode: z
+        .enum(["issue_updated", "user_activity"])
+        .optional()
+        .describe("Date filter mode: 'issue_updated' (default, fast) filters by issue.updated field; 'user_activity' (slow, precise) filters by actual user activity dates including comments, mentions, and field changes history. Use 'user_activity' when you need exact date of user's involvement, e.g., when user was assignee but later changed."),
+    limit: z
+        .number()
+        .int()
+        .positive()
+        .max(200)
+        .optional()
+        .describe("Maximum number of results (default: 100, max: 200)"),
+    skip: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("Number of results to skip for pagination (default: 0)"),
+};
+const issueSearchByUserActivitySchema = z.object(issueSearchByUserActivityArgs);
+export function registerIssueSearchTools(server, client) {
+    server.tool("issue_search_by_user_activity", "Search for issues where specified users had activity (updated, mentioned, reported, assigned, commented) within a given time period. Supports two filter modes: 'issue_updated' (default, fast) uses issue.updated field, 'user_activity' (slow, precise) checks actual user activity dates including comments, mentions, and field changes history. Results are sorted by activity time (most recent first). When 'user_activity' mode is used, each issue includes 'lastActivityDate' field with exact timestamp of user's last activity. Supports pagination via limit and skip parameters. Note: Each issue includes predefined fields only - id, idReadable, summary, project (id, shortName, name), parent (id, idReadable), assignee (id, login, name). Description is not included to reduce response size - use issue_details or issues_details to get full details. Custom fields are not included.", issueSearchByUserActivityArgs, async (rawInput) => {
+        try {
+            const payload = issueSearchByUserActivitySchema.parse(rawInput);
+            const results = await client.searchIssuesByUserActivity({
+                userLogins: payload.userLogins,
+                startDate: payload.startDate,
+                endDate: payload.endDate,
+                dateFilterMode: payload.dateFilterMode,
+                limit: payload.limit,
+                skip: payload.skip,
+            });
+            const response = toolSuccess(results);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=issue-search-tools.js.map

package/dist/src/tools/issue-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 registerIssueTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=issue-tools.d.ts.map

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

@@ -0,0 +1,190 @@
+import { z } from "zod";
+import { toolError, toolSuccess } from "../utils/tool-response.js";
+const issueIdArgs = {
+    issueId: z.string().min(1).describe("Issue code (e.g., PROJ-123)"),
+};
+const issueIdSchema = z.object(issueIdArgs);
+const issueIdsArgs = {
+    issueIds: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(50)
+        .describe("Array of issue codes (e.g., ['PROJ-123', 'PROJ-124']), max 50"),
+};
+const issueIdsSchema = z.object(issueIdsArgs);
+const issueCreateArgs = {
+    projectId: z.string().min(1).describe("Project ID (YouTrack internal id)"),
+    summary: z.string().min(1).describe("Brief issue description"),
+    description: z.string().optional().describe("Full description"),
+    parentIssueId: z.string().optional().describe("Parent issue ID"),
+    assigneeLogin: z.string().optional().describe("Assignee login or me"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+};
+const issueCreateSchema = z.object(issueCreateArgs);
+const issueUpdateArgs = {
+    issueId: z.string().min(1).describe("Issue ID or code"),
+    summary: z.string().optional().describe("New summary"),
+    description: z.string().optional().describe("New description"),
+    parentIssueId: z.string().optional().describe("New parent or empty string to remove"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+};
+const issueUpdateSchema = z.object(issueUpdateArgs);
+const issueAssignArgs = {
+    issueId: z.string().min(1).describe("Issue ID or code"),
+    assigneeLogin: z.string().min(1).describe("Assignee login or me"),
+};
+const issueAssignSchema = z.object(issueAssignArgs);
+const issueCommentCreateArgs = {
+    issueId: z.string().min(1).describe("Issue ID or code"),
+    text: z.string().min(1).describe("Comment text"),
+    usesMarkdown: z.boolean().optional().describe("Use Markdown formatting"),
+};
+const issueCommentCreateSchema = z.object(issueCommentCreateArgs);
+export function registerIssueTools(server, client) {
+    server.tool("issue_lookup", "Get brief information about YouTrack issue. Note: Returns predefined fields only - id, idReadable, summary, description, wikifiedDescription, usesMarkdown, project (id, shortName, name), parent (id, idReadable), assignee (id, login, name). Custom fields are not included.", issueIdArgs, async (rawInput) => {
+        try {
+            const payload = issueIdSchema.parse(rawInput);
+            const issue = await client.getIssue(payload.issueId);
+            const response = toolSuccess(issue);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_details", "Get detailed information about YouTrack issue. Note: Returns predefined fields only - id, idReadable, summary, description, wikifiedDescription, usesMarkdown, created, updated, resolved, project (id, shortName, name), parent (id, idReadable), assignee (id, login, name), reporter (id, login, name), updater (id, login, name). Custom fields are not included.", issueIdArgs, async (rawInput) => {
+        try {
+            const payload = issueIdSchema.parse(rawInput);
+            const details = await client.getIssueDetails(payload.issueId);
+            const response = toolSuccess(details);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_comments", "Get issue comments. Note: Returns predefined fields only - id, text, textPreview, usesMarkdown, author (id, login, name), created, updated.", issueIdArgs, async (rawInput) => {
+        try {
+            const payload = issueIdSchema.parse(rawInput);
+            const comments = await client.getIssueComments(payload.issueId);
+            const response = toolSuccess(comments);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_create", "Create new issue in YouTrack. Note: Response includes standard fields only (id, idReadable, summary, description, wikifiedDescription, usesMarkdown, project, parent, assignee). Custom fields are not included.", issueCreateArgs, async (rawInput) => {
+        try {
+            const payload = issueCreateSchema.parse(rawInput);
+            const issue = await client.createIssue({
+                project: payload.projectId,
+                summary: payload.summary,
+                description: payload.description,
+                parentIssueId: payload.parentIssueId,
+                assigneeLogin: payload.assigneeLogin,
+                usesMarkdown: payload.usesMarkdown,
+            });
+            const response = toolSuccess(issue);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_update", "Update existing issue. Note: Response includes standard fields only (id, idReadable, summary, description, wikifiedDescription, usesMarkdown, project, parent, assignee). Custom fields are not included.", issueUpdateArgs, async (rawInput) => {
+        try {
+            const payload = issueUpdateSchema.parse(rawInput);
+            if (payload.summary === undefined &&
+                payload.description === undefined &&
+                payload.parentIssueId === undefined) {
+                throw new Error("At least one field must be provided for update");
+            }
+            const issue = await client.updateIssue({
+                issueId: payload.issueId,
+                summary: payload.summary,
+                description: payload.description,
+                parentIssueId: payload.parentIssueId,
+                usesMarkdown: payload.usesMarkdown,
+            });
+            const response = toolSuccess(issue);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_assign", "Assign assignee to issue. Note: Response includes standard fields only (id, idReadable, summary, description, wikifiedDescription, usesMarkdown, project, parent, assignee). Custom fields are not included.", issueAssignArgs, async (rawInput) => {
+        try {
+            const payload = issueAssignSchema.parse(rawInput);
+            const issue = await client.assignIssue({
+                issueId: payload.issueId,
+                assigneeLogin: payload.assigneeLogin,
+            });
+            const response = toolSuccess(issue);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issue_comment_create", "Add comment to issue. Note: Response includes comment fields - id, text, textPreview, usesMarkdown, author (id, login, name), created, updated.", issueCommentCreateArgs, async (rawInput) => {
+        try {
+            const payload = issueCommentCreateSchema.parse(rawInput);
+            const comment = await client.createIssueComment({
+                issueId: payload.issueId,
+                text: payload.text,
+                usesMarkdown: payload.usesMarkdown,
+            });
+            const response = toolSuccess(comment);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issues_lookup", "Get brief information about multiple YouTrack issues (batch mode, max 50). Note: Returns predefined fields only - id, idReadable, summary, description, wikifiedDescription, usesMarkdown, project (id, shortName, name), parent (id, idReadable), assignee (id, login, name). Custom fields are not included.", issueIdsArgs, async (rawInput) => {
+        try {
+            const payload = issueIdsSchema.parse(rawInput);
+            const result = await client.getIssues(payload.issueIds);
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issues_details", "Get detailed information about multiple YouTrack issues (batch mode, max 50). Note: Returns predefined fields only - id, idReadable, summary, description, wikifiedDescription, usesMarkdown, created, updated, resolved, project (id, shortName, name), parent (id, idReadable), assignee (id, login, name), reporter (id, login, name), updater (id, login, name). Custom fields are not included.", issueIdsArgs, async (rawInput) => {
+        try {
+            const payload = issueIdsSchema.parse(rawInput);
+            const result = await client.getIssuesDetails(payload.issueIds);
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+    server.tool("issues_comments", "Get comments for multiple YouTrack issues (batch mode, max 50). Note: Returns predefined fields only - id, text, textPreview, usesMarkdown, author (id, login, name), created, updated.", issueIdsArgs, async (rawInput) => {
+        try {
+            const payload = issueIdsSchema.parse(rawInput);
+            const result = await client.getMultipleIssuesComments(payload.issueIds);
+            const response = toolSuccess(result);
+            return response;
+        }
+        catch (error) {
+            const errorResponse = toolError(error);
+            return errorResponse;
+        }
+    });
+}
+//# sourceMappingURL=issue-tools.js.map

package/dist/src/tools/project-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 registerProjectTools(server: McpServer, client: YoutrackClient): void;
+//# sourceMappingURL=project-tools.d.ts.map