@shortcut/mcp 0.15.2 → 0.17.0

package/dist/workflows-TjriXV16.js

@@ -0,0 +1,1691 @@
+import { File } from "node:buffer";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+//#region src/client/cache.ts
+/**
+* Simple key/value cache.
+*
+* It only supports setting **all** values at once. You cannot add to the cache over time.
+* It tracks staleness and is hard coded to expire after 5 minutes.
+*/
+var Cache = class {
+	cache;
+	age;
+	constructor() {
+		this.cache = /* @__PURE__ */ new Map();
+		this.age = 0;
+	}
+	get(key) {
+		return this.cache.get(key) ?? null;
+	}
+	values() {
+		return Array.from(this.cache.values());
+	}
+	setMany(values) {
+		this.cache.clear();
+		for (const [key, value] of values) this.cache.set(key, value);
+		this.age = Date.now();
+	}
+	clear() {
+		this.cache.clear();
+		this.age = 0;
+	}
+	get isStale() {
+		return Date.now() - this.age > 1e3 * 60 * 5;
+	}
+};
+
+//#endregion
+//#region src/client/shortcut.ts
+/**
+* This is a thin wrapper over the official Shortcut API client.
+*
+* Its main reasons for existing are:
+* - Add a caching layer for common calls like fetching members or teams.
+* - Unwrap and simplify some response types.
+* - Only expose a subset of methods and a subset of the possible input parameters to those methods.
+*/
+var ShortcutClientWrapper = class {
+	currentUser = null;
+	userCache;
+	teamCache;
+	workflowCache;
+	customFieldCache;
+	constructor(client) {
+		this.client = client;
+		this.userCache = new Cache();
+		this.teamCache = new Cache();
+		this.workflowCache = new Cache();
+		this.customFieldCache = new Cache();
+	}
+	getNextPageToken(next) {
+		let next_page_token = null;
+		if (next) try {
+			const [, t] = /next=(.+)(?:&|$)/.exec(next) || [];
+			if (t) next_page_token = t;
+		} catch {}
+		return next_page_token;
+	}
+	async loadMembers() {
+		if (this.userCache.isStale) {
+			const response = await this.client.listMembers({});
+			const members = response?.data ?? null;
+			if (members) this.userCache.setMany(members.map((member) => [member.id, member]));
+		}
+	}
+	async loadTeams() {
+		if (this.teamCache.isStale) {
+			const response = await this.client.listGroups();
+			const groups = response?.data ?? null;
+			if (groups) this.teamCache.setMany(groups.map((group) => [group.id, group]));
+		}
+	}
+	async loadWorkflows() {
+		if (this.workflowCache.isStale) {
+			const response = await this.client.listWorkflows();
+			const workflows = response?.data ?? null;
+			if (workflows) this.workflowCache.setMany(workflows.map((workflow) => [workflow.id, workflow]));
+		}
+	}
+	async loadCustomFields() {
+		if (this.customFieldCache.isStale) {
+			const response = await this.client.listCustomFields();
+			const customFields = response?.data ?? null;
+			if (customFields) this.customFieldCache.setMany(customFields.map((customField) => [customField.id, customField]));
+		}
+	}
+	async getCurrentUser() {
+		if (this.currentUser) return this.currentUser;
+		const response = await this.client.getCurrentMemberInfo();
+		const user$1 = response?.data;
+		if (!user$1) return null;
+		this.currentUser = user$1;
+		return user$1;
+	}
+	async getUser(userId) {
+		const response = await this.client.getMember(userId, {});
+		const user$1 = response?.data;
+		if (!user$1) return null;
+		return user$1;
+	}
+	async getUserMap(userIds) {
+		await this.loadMembers();
+		return new Map(userIds.map((id) => [id, this.userCache.get(id)]).filter((user$1) => user$1[1] !== null));
+	}
+	async getUsers(userIds) {
+		await this.loadMembers();
+		return userIds.map((id) => this.userCache.get(id)).filter((user$1) => user$1 !== null);
+	}
+	async listMembers() {
+		await this.loadMembers();
+		const members = Array.from(this.userCache.values());
+		return members;
+	}
+	async getWorkflowMap(workflowIds) {
+		await this.loadWorkflows();
+		return new Map(workflowIds.map((id) => [id, this.workflowCache.get(id)]).filter((workflow) => workflow[1] !== null));
+	}
+	async getWorkflows() {
+		await this.loadWorkflows();
+		return Array.from(this.workflowCache.values());
+	}
+	async getWorkflow(workflowPublicId) {
+		const response = await this.client.getWorkflow(workflowPublicId);
+		const workflow = response?.data;
+		if (!workflow) return null;
+		return workflow;
+	}
+	async getTeams() {
+		await this.loadTeams();
+		const teams = Array.from(this.teamCache.values());
+		return teams;
+	}
+	async getTeamMap(teamIds) {
+		await this.loadTeams();
+		return new Map(teamIds.map((id) => [id, this.teamCache.get(id)]).filter((team) => team[1] !== null));
+	}
+	async getTeam(teamPublicId) {
+		const response = await this.client.getGroup(teamPublicId);
+		const group = response?.data;
+		if (!group) return null;
+		return group;
+	}
+	async createStory(params) {
+		const response = await this.client.createStory(params);
+		const story = response?.data ?? null;
+		if (!story) throw new Error(`Failed to create the story: ${response.status}`);
+		return story;
+	}
+	async updateStory(storyPublicId, params) {
+		const response = await this.client.updateStory(storyPublicId, params);
+		const story = response?.data ?? null;
+		if (!story) throw new Error(`Failed to update the story: ${response.status}`);
+		return story;
+	}
+	async getStory(storyPublicId) {
+		const response = await this.client.getStory(storyPublicId);
+		const story = response?.data ?? null;
+		if (!story) return null;
+		return story;
+	}
+	async getEpic(epicPublicId) {
+		const response = await this.client.getEpic(epicPublicId);
+		const epic = response?.data ?? null;
+		if (!epic) return null;
+		return epic;
+	}
+	async getIteration(iterationPublicId) {
+		const response = await this.client.getIteration(iterationPublicId);
+		const iteration = response?.data ?? null;
+		if (!iteration) return null;
+		return iteration;
+	}
+	async getMilestone(milestonePublicId) {
+		const response = await this.client.getMilestone(milestonePublicId);
+		const milestone = response?.data ?? null;
+		if (!milestone) return null;
+		return milestone;
+	}
+	async searchStories(query, nextToken) {
+		const response = await this.client.searchStories({
+			query,
+			page_size: 25,
+			detail: "full",
+			next: nextToken
+		});
+		const stories = response?.data?.data;
+		const total = response?.data?.total;
+		const next = response?.data?.next;
+		if (!stories) return {
+			stories: null,
+			total: null,
+			next_page_token: null
+		};
+		return {
+			stories,
+			total,
+			next_page_token: this.getNextPageToken(next)
+		};
+	}
+	async searchIterations(query, nextToken) {
+		const response = await this.client.searchIterations({
+			query,
+			page_size: 25,
+			detail: "full",
+			next: nextToken
+		});
+		const iterations = response?.data?.data;
+		const total = response?.data?.total;
+		const next = response?.data?.next;
+		if (!iterations) return {
+			iterations: null,
+			total: null,
+			next_page_token: null
+		};
+		return {
+			iterations,
+			total,
+			next_page_token: this.getNextPageToken(next)
+		};
+	}
+	async getActiveIteration(teamIds) {
+		const response = await this.client.listIterations();
+		const iterations = response?.data;
+		if (!iterations) return /* @__PURE__ */ new Map();
+		const [today] = (/* @__PURE__ */ new Date()).toISOString().split("T");
+		const activeIterationByTeam = iterations.reduce((acc, iteration) => {
+			if (iteration.status !== "started") return acc;
+			const [startDate] = new Date(iteration.start_date).toISOString().split("T");
+			const [endDate] = new Date(iteration.end_date).toISOString().split("T");
+			if (!startDate || !endDate) return acc;
+			if (startDate > today || endDate < today) return acc;
+			if (!iteration.group_ids?.length) iteration.group_ids = ["none"];
+			for (const groupId of iteration.group_ids) {
+				if (groupId !== "none" && !teamIds.includes(groupId)) continue;
+				const prevIterations = acc.get(groupId);
+				if (prevIterations) acc.set(groupId, prevIterations.concat([iteration]));
+				else acc.set(groupId, [iteration]);
+			}
+			return acc;
+		}, /* @__PURE__ */ new Map());
+		return activeIterationByTeam;
+	}
+	async getUpcomingIteration(teamIds) {
+		const response = await this.client.listIterations();
+		const iterations = response?.data;
+		if (!iterations) return /* @__PURE__ */ new Map();
+		const [today] = (/* @__PURE__ */ new Date()).toISOString().split("T");
+		const upcomingIterationByTeam = iterations.reduce((acc, iteration) => {
+			if (iteration.status !== "unstarted") return acc;
+			const [startDate] = new Date(iteration.start_date).toISOString().split("T");
+			const [endDate] = new Date(iteration.end_date).toISOString().split("T");
+			if (!startDate || !endDate) return acc;
+			if (startDate < today) return acc;
+			if (!iteration.group_ids?.length) iteration.group_ids = ["none"];
+			for (const groupId of iteration.group_ids) {
+				if (groupId !== "none" && !teamIds.includes(groupId)) continue;
+				const prevIterations = acc.get(groupId);
+				if (prevIterations) acc.set(groupId, prevIterations.concat([iteration]));
+				else acc.set(groupId, [iteration]);
+			}
+			return acc;
+		}, /* @__PURE__ */ new Map());
+		return upcomingIterationByTeam;
+	}
+	async searchEpics(query, nextToken) {
+		const response = await this.client.searchEpics({
+			query,
+			page_size: 25,
+			detail: "full",
+			next: nextToken
+		});
+		const epics = response?.data?.data;
+		const total = response?.data?.total;
+		const next = response?.data?.next;
+		if (!epics) return {
+			epics: null,
+			total: null,
+			next_page_token: null
+		};
+		return {
+			epics,
+			total,
+			next_page_token: this.getNextPageToken(next)
+		};
+	}
+	async searchMilestones(query, nextToken) {
+		const response = await this.client.searchMilestones({
+			query,
+			page_size: 25,
+			detail: "full",
+			next: nextToken
+		});
+		const milestones = response?.data?.data;
+		const total = response?.data?.total;
+		const next = response?.data?.next;
+		if (!milestones) return {
+			milestones: null,
+			total: null,
+			next_page_token: null
+		};
+		return {
+			milestones,
+			total,
+			next_page_token: this.getNextPageToken(next)
+		};
+	}
+	async listIterationStories(iterationPublicId, includeDescription = false) {
+		const response = await this.client.listIterationStories(iterationPublicId, { includes_description: includeDescription });
+		const stories = response?.data;
+		if (!stories) return {
+			stories: null,
+			total: null
+		};
+		return {
+			stories,
+			total: stories.length
+		};
+	}
+	async createStoryComment(storyPublicId, params) {
+		const response = await this.client.createStoryComment(storyPublicId, params);
+		const storyComment = response?.data ?? null;
+		if (!storyComment) throw new Error(`Failed to create the comment: ${response.status}`);
+		return storyComment;
+	}
+	async createIteration(params) {
+		const response = await this.client.createIteration(params);
+		const iteration = response?.data ?? null;
+		if (!iteration) throw new Error(`Failed to create the iteration: ${response.status}`);
+		return iteration;
+	}
+	async createEpic(params) {
+		const response = await this.client.createEpic(params);
+		const epic = response?.data ?? null;
+		if (!epic) throw new Error(`Failed to create the epic: ${response.status}`);
+		return epic;
+	}
+	async addTaskToStory(storyPublicId, taskParams) {
+		const { description, ownerIds } = taskParams;
+		const params = {
+			description,
+			owner_ids: ownerIds
+		};
+		const response = await this.client.createTask(storyPublicId, params);
+		const task = response?.data ?? null;
+		if (!task) throw new Error(`Failed to create the task: ${response.status}`);
+		return task;
+	}
+	async addRelationToStory(storyPublicId, linkedStoryId, verb) {
+		const response = await this.client.createStoryLink({
+			object_id: linkedStoryId,
+			subject_id: storyPublicId,
+			verb
+		});
+		const storyLink = response?.data ?? null;
+		if (!storyLink) throw new Error(`Failed to create the story links: ${response.status}`);
+		return storyLink;
+	}
+	async getTask(storyPublicId, taskPublicId) {
+		const response = await this.client.getTask(storyPublicId, taskPublicId);
+		const task = response?.data ?? null;
+		if (!task) throw new Error(`Failed to get the task: ${response.status}`);
+		return task;
+	}
+	async updateTask(storyPublicId, taskPublicId, taskParams) {
+		const { description, ownerIds } = taskParams;
+		const params = {
+			description,
+			owner_ids: ownerIds,
+			complete: taskParams.isCompleted
+		};
+		const response = await this.client.updateTask(storyPublicId, taskPublicId, params);
+		const task = response?.data ?? null;
+		if (!task) throw new Error(`Failed to update the task: ${response.status}`);
+		return task;
+	}
+	async addExternalLinkToStory(storyPublicId, externalLink) {
+		const story = await this.getStory(storyPublicId);
+		if (!story) throw new Error(`Story ${storyPublicId} not found`);
+		const currentLinks = story.external_links || [];
+		if (currentLinks.some((link) => link.toLowerCase() === externalLink.toLowerCase())) return story;
+		const updatedLinks = [...currentLinks, externalLink];
+		return await this.updateStory(storyPublicId, { external_links: updatedLinks });
+	}
+	async removeExternalLinkFromStory(storyPublicId, externalLink) {
+		const story = await this.getStory(storyPublicId);
+		if (!story) throw new Error(`Story ${storyPublicId} not found`);
+		const currentLinks = story.external_links || [];
+		const updatedLinks = currentLinks.filter((link) => link.toLowerCase() !== externalLink.toLowerCase());
+		return await this.updateStory(storyPublicId, { external_links: updatedLinks });
+	}
+	async getStoriesByExternalLink(externalLink) {
+		const response = await this.client.getExternalLinkStories({ external_link: externalLink.toLowerCase() });
+		const stories = response?.data;
+		if (!stories) return {
+			stories: null,
+			total: null
+		};
+		return {
+			stories,
+			total: stories.length
+		};
+	}
+	async setStoryExternalLinks(storyPublicId, externalLinks) {
+		return await this.updateStory(storyPublicId, { external_links: externalLinks });
+	}
+	async createDoc(params) {
+		const response = await this.client.createDoc(params);
+		const doc = response?.data ?? null;
+		if (!doc) throw new Error(`Failed to create the document: ${response.status}`);
+		return doc;
+	}
+	async listDocs() {
+		const response = await this.client.listDocs();
+		if (response.status === 403) throw new Error("Docs feature disabled for this workspace.");
+		return response?.data ?? null;
+	}
+	async searchDocuments({ title, archived, createdByCurrentUser, followedByCurrentUser, pageSize = 25, nextPageToken }) {
+		const response = await this.client.searchDocuments({
+			title,
+			archived,
+			created_by_me: createdByCurrentUser,
+			followed_by_me: followedByCurrentUser,
+			page_size: pageSize,
+			next: nextPageToken
+		});
+		if (response.status === 403) throw new Error("Docs feature disabled for this workspace.");
+		const documents = response?.data?.data;
+		const total = response?.data?.total;
+		const next = response?.data?.next;
+		if (!documents) return {
+			documents: null,
+			total: null,
+			next_page_token: null
+		};
+		return {
+			documents,
+			total,
+			next_page_token: this.getNextPageToken(next)
+		};
+	}
+	async getDocById(docId) {
+		const response = await this.client.getDoc(docId);
+		if (response.status === 403) throw new Error("Docs feature disabled for this workspace.");
+		return response?.data ?? null;
+	}
+	async uploadFile(storyId, filePath) {
+		const fileContent = readFileSync(filePath);
+		const fileName = basename(filePath);
+		const file = new File([fileContent], fileName);
+		const response = await this.client.uploadFiles({
+			story_id: storyId,
+			file0: file
+		});
+		const uploadedFile = response?.data ?? null;
+		if (!uploadedFile?.length) throw new Error(`Failed to upload the file: ${response.status}`);
+		return uploadedFile[0];
+	}
+	async getCustomFieldMap(customFieldIds) {
+		await this.loadCustomFields();
+		return new Map(customFieldIds.map((id) => [id, this.customFieldCache.get(id)]).filter((customField) => customField[1] !== null));
+	}
+	async getCustomFields() {
+		await this.loadCustomFields();
+		return Array.from(this.customFieldCache.values());
+	}
+};
+
+//#endregion
+//#region package.json
+var name = "@shortcut/mcp";
+var version = "0.17.0";
+
+//#endregion
+//#region src/mcp/CustomMcpServer.ts
+var CustomMcpServer = class extends McpServer {
+	readonly;
+	tools;
+	constructor({ readonly, tools }) {
+		super({
+			name,
+			version
+		});
+		this.readonly = readonly;
+		this.tools = new Set(tools || []);
+	}
+	shouldAddTool(name$1) {
+		if (!this.tools.size) return true;
+		const [entityType] = name$1.split("-");
+		if (this.tools.has(entityType) || this.tools.has(name$1)) return true;
+		return false;
+	}
+	addToolWithWriteAccess(...args) {
+		if (this.readonly) return null;
+		if (!this.shouldAddTool(args[0])) return null;
+		return super.tool(...args);
+	}
+	addToolWithReadAccess(...args) {
+		if (!this.shouldAddTool(args[0])) return null;
+		return super.tool(...args);
+	}
+	tool() {
+		throw new Error("Call addToolWithReadAccess or addToolWithWriteAccess instead.");
+	}
+};
+
+//#endregion
+//#region src/tools/base.ts
+/**
+* Base class for all tools.
+*/
+var BaseTools = class {
+	constructor(client) {
+		this.client = client;
+	}
+	renameEntityProps(entity) {
+		if (!entity || typeof entity !== "object") return entity;
+		const renames = [
+			["team_id", null],
+			["entity_type", null],
+			["group_id", "team_id"],
+			["group_ids", "team_ids"],
+			["milestone_id", "objective_id"],
+			["milestone_ids", "objective_ids"]
+		];
+		for (const [from, to] of renames) if (from in entity) {
+			const value = entity[from];
+			delete entity[from];
+			if (to) entity = {
+				...entity,
+				[to]: value
+			};
+		}
+		return entity;
+	}
+	mergeRelatedEntities(relatedEntities) {
+		return relatedEntities.reduce((acc, obj) => {
+			if (!obj) return acc;
+			for (const [key, value] of Object.entries(obj)) acc[key] = {
+				...acc[key] || {},
+				...value
+			};
+			return acc;
+		}, {});
+	}
+	getSimplifiedMember(entity) {
+		if (!entity) return null;
+		const { id, disabled, role, profile: { is_owner, name: name$1, email_address, mention_name } } = entity;
+		return {
+			id,
+			name: name$1,
+			email_address,
+			mention_name,
+			role,
+			disabled,
+			is_owner
+		};
+	}
+	getSimplifiedStory(entity, kind) {
+		if (!entity) return null;
+		const { id, name: name$1, app_url, archived, group_id, epic_id, iteration_id, workflow_id, workflow_state_id, owner_ids, requested_by_id, estimate, labels, comments, description, external_links, story_links, pull_requests, formatted_vcs_branch_name, branches, parent_story_id, sub_task_story_ids, tasks, custom_fields, blocked, blocker } = entity;
+		const additionalFields = {};
+		if (kind === "simple") {
+			additionalFields.description = description;
+			additionalFields.estimate = estimate ?? null;
+			additionalFields.comments = (comments || []).filter((c) => !c.deleted).map(({ id: id$1, author_id, text }) => ({
+				id: id$1,
+				author_id: author_id ?? null,
+				text: text ?? ""
+			}));
+			additionalFields.labels = (labels || []).map((l) => l.name);
+			additionalFields.external_links = external_links || [];
+			additionalFields.suggested_branch_name = formatted_vcs_branch_name ?? null;
+			additionalFields.pull_requests = (pull_requests || []).map((pr) => pr.url);
+			additionalFields.branches = (branches || []).map((b) => b.name);
+			additionalFields.related_stories = (story_links || []).map((sl) => sl.type === "object" ? sl.subject_id : sl.object_id);
+			additionalFields.tasks = (tasks || []).map((t) => ({
+				id: t.id,
+				description: t.description,
+				complete: t.complete
+			}));
+			additionalFields.custom_fields = (custom_fields || []).map((field) => field.value_id);
+			additionalFields.blocked = blocked;
+			additionalFields.blocker = blocker;
+		}
+		return {
+			id,
+			name: name$1,
+			app_url,
+			archived,
+			team_id: group_id || null,
+			epic_id: epic_id || null,
+			iteration_id: iteration_id || null,
+			workflow_id,
+			workflow_state_id,
+			owner_ids,
+			requested_by_id,
+			parent_story_id: parent_story_id ?? null,
+			sub_task_ids: sub_task_story_ids ?? [],
+			...additionalFields
+		};
+	}
+	getSimplifiedWorkflow(entity) {
+		if (!entity) return null;
+		const { id, name: name$1, states } = entity;
+		return {
+			id,
+			name: name$1,
+			states: states.map((state) => ({
+				id: state.id,
+				name: state.name,
+				type: state.type
+			}))
+		};
+	}
+	getSimplifiedTeam(entity) {
+		if (!entity) return null;
+		const { archived, id, name: name$1, mention_name, member_ids, workflow_ids, default_workflow_id } = entity;
+		return {
+			id,
+			name: name$1,
+			archived,
+			mention_name,
+			member_ids,
+			workflow_ids,
+			default_workflow_id: default_workflow_id ?? null
+		};
+	}
+	getSimplifiedObjective(entity) {
+		if (!entity) return null;
+		const { app_url, id, name: name$1, archived, state, categories } = entity;
+		return {
+			app_url,
+			id,
+			name: name$1,
+			archived,
+			state,
+			categories: categories.map((cat) => cat.name)
+		};
+	}
+	getSimplifiedEpic(entity, kind) {
+		if (!entity) return null;
+		const { id, name: name$1, app_url, archived, group_id, state, milestone_id, comments, description, deadline, owner_ids } = entity;
+		const additionalFields = {};
+		if (kind === "simple") {
+			additionalFields.comments = (comments || []).filter((comment) => !comment.deleted).map(({ id: id$1, author_id, text }) => ({
+				id: id$1,
+				author_id,
+				text
+			}));
+			additionalFields.description = description;
+			additionalFields.deadline = deadline ?? null;
+		}
+		return {
+			id,
+			name: name$1,
+			app_url,
+			archived,
+			state,
+			team_id: group_id || null,
+			objective_id: milestone_id || null,
+			owner_ids,
+			...additionalFields
+		};
+	}
+	getSimplifiedIteration(entity) {
+		if (!entity) return null;
+		const { id, name: name$1, app_url, group_ids, status, start_date, end_date } = entity;
+		return {
+			id,
+			name: name$1,
+			app_url,
+			team_ids: group_ids,
+			status,
+			start_date,
+			end_date
+		};
+	}
+	async getRelatedEntitiesForTeam(entity) {
+		if (!entity) return {
+			users: {},
+			workflows: {}
+		};
+		const { member_ids, workflow_ids } = entity;
+		const [users, workflows] = await Promise.all([this.client.getUserMap(member_ids), this.client.getWorkflowMap(workflow_ids)]);
+		return {
+			users: Object.fromEntries(member_ids.map((id) => this.getSimplifiedMember(users.get(id))).filter((member) => member !== null).map((member) => [member.id, member])),
+			workflows: Object.fromEntries(workflow_ids.map((id) => this.getSimplifiedWorkflow(workflows.get(id))).filter((workflow) => workflow !== null).map((workflow) => [workflow.id, workflow]))
+		};
+	}
+	async getRelatedEntitiesForIteration(entity) {
+		if (!entity) return {
+			teams: {},
+			users: {},
+			workflows: {}
+		};
+		const { group_ids } = entity;
+		const teams = await this.client.getTeamMap(group_ids || []);
+		const relatedEntitiesForTeams = await Promise.all(Array.from(teams.values()).map((team) => this.getRelatedEntitiesForTeam(team)));
+		const { users, workflows } = this.mergeRelatedEntities(relatedEntitiesForTeams);
+		return {
+			teams: Object.fromEntries([...teams.entries()].map(([id, team]) => [id, this.getSimplifiedTeam(team)]).filter(([_, team]) => !!team)),
+			users,
+			workflows
+		};
+	}
+	async getRelatedEntitiesForEpic(entity) {
+		if (!entity) return {
+			users: {},
+			workflows: {},
+			teams: {},
+			objectives: {}
+		};
+		const { group_id, owner_ids, milestone_id, requested_by_id, follower_ids, comments } = entity;
+		const [usersForEpicMap, teams, fullMilestone] = await Promise.all([
+			this.client.getUserMap([...new Set([
+				...owner_ids || [],
+				requested_by_id,
+				...follower_ids || [],
+				...(comments || []).map((comment) => comment.author_id)
+			].filter(Boolean))]),
+			this.client.getTeamMap(group_id ? [group_id] : []),
+			milestone_id ? this.client.getMilestone(milestone_id) : null
+		]);
+		const usersForEpic = Object.fromEntries([...usersForEpicMap.entries()].filter(([_, user$1]) => !!user$1).map(([id, user$1]) => [id, this.getSimplifiedMember(user$1)]));
+		const team = this.getSimplifiedTeam(teams.get(group_id || ""));
+		const { users, workflows } = await this.getRelatedEntitiesForTeam(teams.get(group_id || ""));
+		const milestone = this.getSimplifiedObjective(fullMilestone);
+		return {
+			users: this.mergeRelatedEntities([usersForEpic, users]),
+			teams: team ? { [team.id]: team } : {},
+			objectives: milestone ? { [milestone.id]: milestone } : {},
+			workflows
+		};
+	}
+	async getRelatedEntitiesForStory(entity, kind) {
+		const { group_id, iteration_id, epic_id, owner_ids, requested_by_id, follower_ids, workflow_id, comments, custom_fields } = entity;
+		const [fullUsersForStory, teamsForStory, workflowsForStory, iteration, epic] = await Promise.all([
+			this.client.getUserMap([...new Set([
+				...owner_ids || [],
+				requested_by_id,
+				...follower_ids || [],
+				...(comments || []).map((comment) => comment.author_id || "")
+			].filter(Boolean))]),
+			this.client.getTeamMap(group_id ? [group_id] : []),
+			this.client.getWorkflowMap(workflow_id ? [workflow_id] : []),
+			iteration_id ? this.client.getIteration(iteration_id) : null,
+			epic_id ? this.client.getEpic(epic_id) : null
+		]);
+		const usersForStory = Object.fromEntries([...fullUsersForStory.entries()].filter(([_, user$1]) => !!user$1).map(([id, user$1]) => [id, this.getSimplifiedMember(user$1)]));
+		const simplifiedIteration = this.getSimplifiedIteration(iteration);
+		const simplifiedEpic = this.getSimplifiedEpic(epic, kind);
+		const teamForStory = teamsForStory.get(group_id || "");
+		const workflowForStory = this.getSimplifiedWorkflow(workflowsForStory.get(workflow_id));
+		const { users: usersForTeam, workflows: workflowsForTeam } = await this.getRelatedEntitiesForTeam(teamForStory);
+		const { users: usersForIteration, workflows: workflowsForIteration, teams: teamsForIteration } = await this.getRelatedEntitiesForIteration(iteration);
+		const { users: usersForEpic, workflows: workflowsForEpic, teams: teamsForEpic, objectives } = await this.getRelatedEntitiesForEpic(epic);
+		const users = this.mergeRelatedEntities([
+			usersForTeam,
+			usersForStory,
+			usersForIteration,
+			usersForEpic
+		]);
+		const workflows = this.mergeRelatedEntities([
+			workflowsForTeam,
+			workflowsForIteration,
+			workflowsForEpic,
+			workflowForStory ? { [workflowForStory.id]: workflowForStory } : {}
+		]);
+		const simplifiedStoryTeam = this.getSimplifiedTeam(teamForStory);
+		const teams = this.mergeRelatedEntities([
+			teamsForIteration,
+			teamsForEpic,
+			simplifiedStoryTeam ? { [simplifiedStoryTeam.id]: simplifiedStoryTeam } : {}
+		]);
+		const epics = simplifiedEpic ? { [simplifiedEpic.id]: simplifiedEpic } : {};
+		const iterations = simplifiedIteration ? { [simplifiedIteration.id]: simplifiedIteration } : {};
+		const relatedCustomFields = {};
+		if (custom_fields?.length) {
+			const customFieldMap = await this.client.getCustomFieldMap(custom_fields.map((cf) => cf.field_id));
+			custom_fields.forEach((cf) => {
+				const field = customFieldMap.get(cf.field_id);
+				if (!field) return;
+				const value = field.values?.find((v) => v.id === cf.value_id);
+				if (!value) return;
+				relatedCustomFields[cf.value_id] = {
+					field_id: cf.field_id,
+					value_id: cf.value_id,
+					field_name: field.name,
+					value_name: value.value
+				};
+			});
+		}
+		return {
+			users,
+			epics,
+			iterations,
+			workflows,
+			teams,
+			objectives,
+			custom_fields: relatedCustomFields
+		};
+	}
+	async getRelatedEntities(entity, kind) {
+		if (entity.entity_type === "group") return this.getRelatedEntitiesForTeam(entity);
+		if (entity.entity_type === "iteration") return this.getRelatedEntitiesForIteration(entity);
+		if (entity.entity_type === "epic") return this.getRelatedEntitiesForEpic(entity);
+		if (entity.entity_type === "story") return this.getRelatedEntitiesForStory(entity, kind);
+		return {};
+	}
+	getSimplifiedEntity(entity, kind) {
+		if (entity.entity_type === "group") return this.getSimplifiedTeam(entity);
+		if (entity.entity_type === "iteration") return this.getSimplifiedIteration(entity);
+		if (entity.entity_type === "epic") return this.getSimplifiedEpic(entity, kind);
+		if (entity.entity_type === "story") return this.getSimplifiedStory(entity, kind);
+		if (entity.entity_type === "milestone") return this.getSimplifiedObjective(entity);
+		if (entity.entity_type === "workflow") return this.getSimplifiedWorkflow(entity);
+		return entity;
+	}
+	async entityWithRelatedEntities(entity, entityType = "entity", full = false) {
+		const finalEntity = full ? entity : this.getSimplifiedEntity(entity, "simple");
+		const relatedEntities = await this.getRelatedEntities(entity, full ? "full" : "simple");
+		return {
+			[entityType]: this.renameEntityProps(finalEntity),
+			relatedEntities
+		};
+	}
+	async entitiesWithRelatedEntities(entities, entityType = "entities") {
+		const relatedEntities = await Promise.all(entities.map((entity) => this.getRelatedEntities(entity, "list")));
+		return {
+			[entityType]: entities.map((entity) => this.getSimplifiedEntity(entity, "list")),
+			relatedEntities: this.mergeRelatedEntities(relatedEntities)
+		};
+	}
+	toResult(message, data, paginationToken) {
+		return { content: [{
+			type: "text",
+			text: `${message}${data !== void 0 ? `\n\n<json>\n${JSON.stringify(data, null, 2)}\n</json>${paginationToken ? `\n\n<next-page-token>${paginationToken}</next-page-token>` : ""}` : ""}`
+		}] };
+	}
+};
+
+//#endregion
+//#region src/tools/documents.ts
+var DocumentTools = class DocumentTools extends BaseTools {
+	static create(client, server) {
+		const tools = new DocumentTools(client);
+		server.addToolWithWriteAccess("documents-create", "Create a new document in Shortcut with a title and content. Returns the document's id, title, and app_url. Note: Use HTML markup for the content (e.g., <p>, <h1>, <ul>, <strong>) rather than Markdown.", {
+			title: z.string().max(256).describe("The title for the new document (max 256 characters)"),
+			content: z.string().describe("The content for the new document in HTML format (e.g., <p>Hello</p>, <h1>Title</h1>, <ul><li>Item</li></ul>)")
+		}, async ({ title, content }) => await tools.createDocument(title, content));
+		server.addToolWithReadAccess("documents-list", "List all documents in Shortcut.", async () => await tools.listDocuments());
+		server.addToolWithReadAccess("documents-search", "Find documents.", {
+			nextPageToken: z.string().optional().describe("If a next_page_token was returned from the search result, pass it in to get the next page of results. Should be combined with the original search parameters."),
+			title: z.string().describe("Find documents matching the specified name"),
+			archived: z.boolean().optional().describe("Find only documents matching the specified archived status"),
+			createdByCurrentUser: z.boolean().optional().describe("Find only documents created by current user"),
+			followedByCurrentUser: z.boolean().optional().describe("Find only documents followed by current user")
+		}, async ({ nextPageToken, title, archived, createdByCurrentUser, followedByCurrentUser }) => await tools.searchDocuments({
+			title,
+			archived,
+			createdByCurrentUser,
+			followedByCurrentUser
+		}, nextPageToken));
+		server.addToolWithReadAccess("documents-get-by-id", "Get a document as markdown by its ID", { docId: z.string().describe("The ID of the document to retrieve") }, async ({ docId }) => await tools.getDocumentById(docId));
+		return tools;
+	}
+	async createDocument(title, content) {
+		try {
+			const doc = await this.client.createDoc({
+				title,
+				content
+			});
+			return this.toResult("Document created successfully", {
+				id: doc.id,
+				title: doc.title,
+				app_url: doc.app_url
+			});
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error";
+			return this.toResult(`Failed to create document: ${errorMessage}`);
+		}
+	}
+	async listDocuments() {
+		try {
+			const docs = await this.client.listDocs();
+			if (!docs?.length) return this.toResult("No documents were found.");
+			return this.toResult(`Found ${docs.length} documents.`, docs);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error";
+			return this.toResult(`Failed to list documents: ${errorMessage}`);
+		}
+	}
+	async searchDocuments(params, nextPageToken) {
+		try {
+			const { documents, total, next_page_token } = await this.client.searchDocuments({
+				...params,
+				nextPageToken
+			});
+			if (!documents) throw new Error(`Failed to search for document matching your query.`);
+			if (!documents.length) return this.toResult(`Result: No documents found.`);
+			return this.toResult(`Result (${documents.length} shown of ${total} total documents found):`, documents, next_page_token);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error";
+			return this.toResult(`Failed to search documents: ${errorMessage}`);
+		}
+	}
+	async getDocumentById(docId) {
+		try {
+			const doc = await this.client.getDocById(docId);
+			if (!doc) return this.toResult(`Document with ID ${docId} not found.`);
+			return this.toResult(`Document with ID ${docId}`, doc);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error";
+			return this.toResult(`Failed to get document: ${errorMessage}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/tools/utils/search.ts
+const keyRenames = { name: "title" };
+const mapKeyName = (key) => {
+	const lowercaseKey = key.toLowerCase();
+	return keyRenames[lowercaseKey] || lowercaseKey;
+};
+const getKey = (prop) => {
+	if (prop.startsWith("is")) return `is:${mapKeyName(prop.slice(2))}`;
+	if (prop.startsWith("has")) return `has:${mapKeyName(prop.slice(3))}`;
+	return mapKeyName(prop);
+};
+const buildSearchQuery = async (params, currentUser) => {
+	const query = Object.entries(params).map(([key, value]) => {
+		const q = getKey(key);
+		if (key === "owner" || key === "requester") {
+			if (value === "me") return `${q}:${currentUser?.mention_name || value}`;
+			return `${q}:${String(value || "").replace(/^@/, "")}`;
+		}
+		if (typeof value === "boolean") return value ? q : `!${q}`;
+		if (typeof value === "number") return `${q}:${value}`;
+		if (typeof value === "string" && value.includes(" ")) return `${q}:"${value}"`;
+		return `${q}:${value}`;
+	}).join(" ");
+	return query;
+};
+
+//#endregion
+//#region src/tools/utils/validation.ts
+const dateformat = "\\d{4}-\\d{2}-\\d{2}";
+const range = ({ f = "\\*", t = "\\*" }) => `${f}\\.\\.${t}`;
+const variations = [
+	"today",
+	"tomorrow",
+	"yesterday",
+	dateformat,
+	range({ f: "today" }),
+	range({ t: "today" }),
+	range({ f: "yesterday" }),
+	range({ t: "yesterday" }),
+	range({ f: "tomorrow" }),
+	range({ t: "tomorrow" }),
+	range({ f: dateformat }),
+	range({ t: dateformat }),
+	range({
+		f: dateformat,
+		t: dateformat
+	})
+];
+const DATE_REGEXP = /* @__PURE__ */ new RegExp(`^(${variations.join("|")})$`);
+const date = () => z.string().regex(DATE_REGEXP).optional().describe("The date in \"YYYY-MM-DD\" format, or one of the keywords: \"yesterday\", \"today\", \"tomorrow\", or a date range in the format \"YYYY-MM-DD..YYYY-MM-DD\". The date range can also be open ended by using \"*\" for one of the bounds. Examples: \"2023-01-01\", \"today\", \"2023-01-01..*\" (from Jan 1, 2023 to any future date), \"*.2023-01-31\" (any date up to Jan 31, 2023), \"today..*\" (from today onwards), \"*.yesterday\" (any date up to yesterday). The keywords cannot be used to calculate relative dates (e.g. the following are not valid: \"today-1\" or \"tomorrow+1\").");
+const is = (field) => z.boolean().optional().describe(`Find only entities that are ${field} when true, or only entities that are not ${field} when false.`);
+const has = (field) => z.boolean().optional().describe(`Find only entities that have ${field} when true, or only entities that do not have ${field} when false. Example: hasOwner: true will find stories with an owner, hasOwner: false will find stories without an owner.`);
+const user = (field) => z.string().optional().describe(`Find entities where the ${field} match the specified user. This must either be the user\'s mention name or the keyword "me" for the current user.`);
+
+//#endregion
+//#region src/tools/epics.ts
+var EpicTools = class EpicTools extends BaseTools {
+	static create(client, server) {
+		const tools = new EpicTools(client);
+		server.addToolWithReadAccess("epics-get-by-id", "Get a Shortcut epic by public ID", {
+			epicPublicId: z.number().positive().describe("The public ID of the epic to get"),
+			full: z.boolean().optional().default(false).describe("True to return all epic fields from the API. False to return a slim version that excludes uncommon fields")
+		}, async ({ epicPublicId, full }) => await tools.getEpic(epicPublicId, full));
+		server.addToolWithReadAccess("epics-search", "Find Shortcut epics.", {
+			nextPageToken: z.string().optional().describe("If a next_page_token was returned from the search result, pass it in to get the next page of results.  Should be combined with the original search parameters."),
+			id: z.number().optional().describe("Find only epics with the specified public ID"),
+			name: z.string().optional().describe("Find only epics matching the specified name"),
+			description: z.string().optional().describe("Find only epics matching the specified description"),
+			state: z.enum([
+				"unstarted",
+				"started",
+				"done"
+			]).optional().describe("Find only epics matching the specified state"),
+			objective: z.number().optional().describe("Find only epics matching the specified objective"),
+			owner: user("owner"),
+			requester: user("requester"),
+			team: z.string().optional().describe("Find only epics matching the specified team. Should be a team's mention name."),
+			comment: z.string().optional().describe("Find only epics matching the specified comment"),
+			isUnstarted: is("unstarted"),
+			isStarted: is("started"),
+			isDone: is("completed"),
+			isArchived: is("archived").default(false),
+			isOverdue: is("overdue"),
+			hasOwner: has("an owner"),
+			hasComment: has("a comment"),
+			hasDeadline: has("a deadline"),
+			hasLabel: has("a label"),
+			created: date(),
+			updated: date(),
+			completed: date(),
+			due: date()
+		}, async ({ nextPageToken,...params }) => await tools.searchEpics(params, nextPageToken));
+		server.addToolWithWriteAccess("epics-create", "Create a new Shortcut epic.", {
+			name: z.string().describe("The name of the epic"),
+			owner: z.string().optional().describe("The user ID of the owner of the epic"),
+			description: z.string().optional().describe("A description of the epic"),
+			teamId: z.string().optional().describe("The ID of a team to assign the epic to")
+		}, async (params) => await tools.createEpic(params));
+		return tools;
+	}
+	async searchEpics(params, nextToken) {
+		const currentUser = await this.client.getCurrentUser();
+		const query = await buildSearchQuery(params, currentUser);
+		const { epics, total, next_page_token } = await this.client.searchEpics(query, nextToken);
+		if (!epics) throw new Error(`Failed to search for epics matching your query: "${query}"`);
+		if (!epics.length) return this.toResult(`Result: No epics found.`);
+		return this.toResult(`Result (${epics.length} shown of ${total} total epics found):`, await this.entitiesWithRelatedEntities(epics, "epics"), next_page_token);
+	}
+	async getEpic(epicPublicId, full = false) {
+		const epic = await this.client.getEpic(epicPublicId);
+		if (!epic) throw new Error(`Failed to retrieve Shortcut epic with public ID: ${epicPublicId}`);
+		return this.toResult(`Epic: ${epicPublicId}`, await this.entityWithRelatedEntities(epic, "epic", full));
+	}
+	async createEpic({ name: name$1, owner, teamId: group_id, description }) {
+		const epic = await this.client.createEpic({
+			name: name$1,
+			group_id,
+			owner_ids: owner ? [owner] : void 0,
+			description
+		});
+		return this.toResult(`Epic created with ID: ${epic.id}.`);
+	}
+};
+
+//#endregion
+//#region src/tools/iterations.ts
+var IterationTools = class IterationTools extends BaseTools {
+	static create(client, server) {
+		const tools = new IterationTools(client);
+		server.addToolWithReadAccess("iterations-get-stories", "Get stories in a specific iteration by iteration public ID", {
+			iterationPublicId: z.number().positive().describe("The public ID of the iteration"),
+			includeStoryDescriptions: z.boolean().optional().default(false).describe("Indicate whether story descriptions should be included. Including descriptions may take longer and will increase the size of the response.")
+		}, async ({ iterationPublicId, includeStoryDescriptions }) => await tools.getIterationStories(iterationPublicId, includeStoryDescriptions));
+		server.addToolWithReadAccess("iterations-get-by-id", "Get a Shortcut iteration by public ID", {
+			iterationPublicId: z.number().positive().describe("The public ID of the iteration to get"),
+			full: z.boolean().optional().default(false).describe("True to return all iteration fields from the API. False to return a slim version that excludes uncommon fields")
+		}, async ({ iterationPublicId, full }) => await tools.getIteration(iterationPublicId, full));
+		server.addToolWithReadAccess("iterations-search", "Find Shortcut iterations.", {
+			nextPageToken: z.string().optional().describe("If a next_page_token was returned from the search result, pass it in to get the next page of results. Should be combined with the original search parameters."),
+			id: z.number().optional().describe("Find only iterations with the specified public ID"),
+			name: z.string().optional().describe("Find only iterations matching the specified name"),
+			description: z.string().optional().describe("Find only iterations matching the specified description"),
+			state: z.enum([
+				"started",
+				"unstarted",
+				"done"
+			]).optional().describe("Find only iterations matching the specified state"),
+			team: z.string().optional().describe("Find only iterations matching the specified team. This can be a team ID or mention name."),
+			created: date(),
+			updated: date(),
+			startDate: date(),
+			endDate: date()
+		}, async ({ nextPageToken,...params }) => await tools.searchIterations(params, nextPageToken));
+		server.addToolWithWriteAccess("iterations-create", "Create a new Shortcut iteration", {
+			name: z.string().describe("The name of the iteration"),
+			startDate: z.string().describe("The start date of the iteration in YYYY-MM-DD format"),
+			endDate: z.string().describe("The end date of the iteration in YYYY-MM-DD format"),
+			teamId: z.string().optional().describe("The ID of a team to assign the iteration to"),
+			description: z.string().optional().describe("A description of the iteration")
+		}, async (params) => await tools.createIteration(params));
+		server.addToolWithReadAccess("iterations-get-active", "Get the active Shortcut iterations for the current user based on their team memberships", { teamId: z.string().optional().describe("The ID of a team to filter iterations by") }, async ({ teamId }) => await tools.getActiveIterations(teamId));
+		server.addToolWithReadAccess("iterations-get-upcoming", "Get the upcoming Shortcut iterations for the current user based on their team memberships", { teamId: z.string().optional().describe("The ID of a team to filter iterations by") }, async ({ teamId }) => await tools.getUpcomingIterations(teamId));
+		return tools;
+	}
+	async getIterationStories(iterationPublicId, includeDescription) {
+		const { stories } = await this.client.listIterationStories(iterationPublicId, includeDescription);
+		if (!stories) throw new Error(`Failed to retrieve Shortcut stories in iteration with public ID: ${iterationPublicId}.`);
+		return this.toResult(`Result (${stories.length} stories found):`, await this.entitiesWithRelatedEntities(stories, "stories"));
+	}
+	async searchIterations(params, nextToken) {
+		const currentUser = await this.client.getCurrentUser();
+		const query = await buildSearchQuery(params, currentUser);
+		const { iterations, total, next_page_token } = await this.client.searchIterations(query, nextToken);
+		if (!iterations) throw new Error(`Failed to search for iterations matching your query: "${query}".`);
+		if (!iterations.length) return this.toResult(`Result: No iterations found.`);
+		return this.toResult(`Result (${iterations.length} shown of ${total} total iterations found):`, await this.entitiesWithRelatedEntities(iterations, "iterations"), next_page_token);
+	}
+	async getIteration(iterationPublicId, full = false) {
+		const iteration = await this.client.getIteration(iterationPublicId);
+		if (!iteration) throw new Error(`Failed to retrieve Shortcut iteration with public ID: ${iterationPublicId}.`);
+		return this.toResult(`Iteration: ${iterationPublicId}`, await this.entityWithRelatedEntities(iteration, "iteration", full));
+	}
+	async createIteration({ name: name$1, startDate, endDate, teamId, description }) {
+		const iteration = await this.client.createIteration({
+			name: name$1,
+			start_date: startDate,
+			end_date: endDate,
+			group_ids: teamId ? [teamId] : void 0,
+			description
+		});
+		if (!iteration) throw new Error(`Failed to create the iteration.`);
+		return this.toResult(`Iteration created with ID: ${iteration.id}.`);
+	}
+	async getActiveIterations(teamId) {
+		if (teamId) {
+			const team = await this.client.getTeam(teamId);
+			if (!team) throw new Error(`No team found matching id: "${teamId}"`);
+			const result = await this.client.getActiveIteration([teamId]);
+			const iterations = result.get(teamId);
+			if (!iterations?.length) return this.toResult(`Result: No active iterations found for team.`);
+			if (iterations.length === 1) return this.toResult("The active iteration for the team is:", await this.entityWithRelatedEntities(iterations[0], "iteration"));
+			return this.toResult("The active iterations for the team are:", await this.entitiesWithRelatedEntities(iterations, "iterations"));
+		}
+		const currentUser = await this.client.getCurrentUser();
+		if (!currentUser) throw new Error("Failed to retrieve current user.");
+		const teams = await this.client.getTeams();
+		const teamIds = teams.filter((team) => team.member_ids.includes(currentUser.id)).map((team) => team.id);
+		if (!teamIds.length) throw new Error("Current user does not belong to any teams.");
+		const resultsByTeam = await this.client.getActiveIteration(teamIds);
+		const allActiveIterations = [...resultsByTeam.values()].flat();
+		if (!allActiveIterations.length) return this.toResult("Result: No active iterations found for any of your teams.");
+		return this.toResult(`You have ${allActiveIterations.length} active iterations for your teams:`, await this.entitiesWithRelatedEntities(allActiveIterations, "iterations"));
+	}
+	async getUpcomingIterations(teamId) {
+		if (teamId) {
+			const team = await this.client.getTeam(teamId);
+			if (!team) throw new Error(`No team found matching id: "${teamId}"`);
+			const result = await this.client.getUpcomingIteration([teamId]);
+			const iterations = result.get(teamId);
+			if (!iterations?.length) return this.toResult(`Result: No upcoming iterations found for team.`);
+			if (iterations.length === 1) return this.toResult("The next upcoming iteration for the team is:", await this.entityWithRelatedEntities(iterations[0], "iteration"));
+			return this.toResult("The next upcoming iterations for the team are:", await this.entitiesWithRelatedEntities(iterations, "iterations"));
+		}
+		const currentUser = await this.client.getCurrentUser();
+		if (!currentUser) throw new Error("Failed to retrieve current user.");
+		const teams = await this.client.getTeams();
+		const teamIds = teams.filter((team) => team.member_ids.includes(currentUser.id)).map((team) => team.id);
+		if (!teamIds.length) throw new Error("Current user does not belong to any teams.");
+		const resultsByTeam = await this.client.getUpcomingIteration(teamIds);
+		const allUpcomingIterations = [...resultsByTeam.values()].flat();
+		if (!allUpcomingIterations.length) return this.toResult("Result: No upcoming iterations found for any of your teams.");
+		return this.toResult("The upcoming iterations for all your teams are:", await this.entitiesWithRelatedEntities(allUpcomingIterations, "iterations"));
+	}
+};
+
+//#endregion
+//#region src/tools/objectives.ts
+var ObjectiveTools = class ObjectiveTools extends BaseTools {
+	static create(client, server) {
+		const tools = new ObjectiveTools(client);
+		server.addToolWithReadAccess("objectives-get-by-id", "Get a Shortcut objective by public ID", {
+			objectivePublicId: z.number().positive().describe("The public ID of the objective to get"),
+			full: z.boolean().optional().default(false).describe("True to return all objective fields from the API. False to return a slim version that excludes uncommon fields")
+		}, async ({ objectivePublicId, full }) => await tools.getObjective(objectivePublicId, full));
+		server.addToolWithReadAccess("objectives-search", "Find Shortcut objectives.", {
+			nextPageToken: z.string().optional().describe("If a next_page_token was returned from the search result, pass it in to get the next page of results. Should be combined with the original search parameters."),
+			id: z.number().optional().describe("Find objectives matching the specified id"),
+			name: z.string().optional().describe("Find objectives matching the specified name"),
+			description: z.string().optional().describe("Find objectives matching the specified description"),
+			state: z.enum([
+				"unstarted",
+				"started",
+				"done"
+			]).optional().describe("Find objectives matching the specified state"),
+			owner: user("owner"),
+			requester: user("requester"),
+			team: z.string().optional().describe("Find objectives matching the specified team. Should be a team mention name."),
+			isUnstarted: is("unstarted"),
+			isStarted: is("started"),
+			isDone: is("completed"),
+			isArchived: is("archived"),
+			hasOwner: has("an owner"),
+			created: date(),
+			updated: date(),
+			completed: date()
+		}, async ({ nextPageToken,...params }) => await tools.searchObjectives(params, nextPageToken));
+		return tools;
+	}
+	async searchObjectives(params, nextToken) {
+		const currentUser = await this.client.getCurrentUser();
+		const query = await buildSearchQuery(params, currentUser);
+		const { milestones, total, next_page_token } = await this.client.searchMilestones(query, nextToken);
+		if (!milestones) throw new Error(`Failed to search for milestones matching your query: "${query}"`);
+		if (!milestones.length) return this.toResult(`Result: No milestones found.`);
+		return this.toResult(`Result (${milestones.length} shown of ${total} total milestones found):`, await this.entitiesWithRelatedEntities(milestones, "objectives"), next_page_token);
+	}
+	async getObjective(objectivePublicId, full = false) {
+		const objective = await this.client.getMilestone(objectivePublicId);
+		if (!objective) throw new Error(`Failed to retrieve Shortcut objective with public ID: ${objectivePublicId}`);
+		return this.toResult(`Objective: ${objectivePublicId}`, await this.entityWithRelatedEntities(objective, "objective", full));
+	}
+};
+
+//#endregion
+//#region src/tools/stories.ts
+var StoryTools = class StoryTools extends BaseTools {
+	static create(client, server) {
+		const tools = new StoryTools(client);
+		server.addToolWithReadAccess("stories-get-by-id", "Get a Shortcut story by public ID", {
+			storyPublicId: z.number().positive().describe("The public ID of the story to get"),
+			full: z.boolean().optional().default(false).describe("True to return all story fields from the API. False to return a slim version that excludes uncommon fields")
+		}, async ({ storyPublicId, full }) => await tools.getStory(storyPublicId, full));
+		server.addToolWithReadAccess("stories-search", "Find Shortcut stories.", {
+			nextPageToken: z.string().optional().describe("If a next_page_token was returned from the search result, pass it in to get the next page of results. Should be combined with the original search parameters."),
+			id: z.number().optional().describe("Find only stories with the specified public ID"),
+			name: z.string().optional().describe("Find only stories matching the specified name"),
+			description: z.string().optional().describe("Find only stories matching the specified description"),
+			comment: z.string().optional().describe("Find only stories matching the specified comment"),
+			type: z.enum([
+				"feature",
+				"bug",
+				"chore"
+			]).optional().describe("Find only stories of the specified type"),
+			estimate: z.number().optional().describe("Find only stories matching the specified estimate"),
+			branch: z.string().optional().describe("Find only stories matching the specified branch"),
+			commit: z.string().optional().describe("Find only stories matching the specified commit"),
+			pr: z.number().optional().describe("Find only stories matching the specified pull request"),
+			project: z.number().optional().describe("Find only stories matching the specified project"),
+			epic: z.number().optional().describe("Find only stories matching the specified epic"),
+			objective: z.number().optional().describe("Find only stories matching the specified objective"),
+			state: z.string().optional().describe("Find only stories matching the specified state"),
+			label: z.string().optional().describe("Find only stories matching the specified label"),
+			owner: user("owner"),
+			requester: user("requester"),
+			team: z.string().optional().describe("Find only stories matching the specified team. This can be a team mention name or team name."),
+			skillSet: z.string().optional().describe("Find only stories matching the specified skill set"),
+			productArea: z.string().optional().describe("Find only stories matching the specified product area"),
+			technicalArea: z.string().optional().describe("Find only stories matching the specified technical area"),
+			priority: z.string().optional().describe("Find only stories matching the specified priority"),
+			severity: z.string().optional().describe("Find only stories matching the specified severity"),
+			isDone: is("completed"),
+			isStarted: is("started"),
+			isUnstarted: is("unstarted"),
+			isUnestimated: is("unestimated"),
+			isOverdue: is("overdue"),
+			isArchived: is("archived").default(false),
+			isBlocker: is("blocking"),
+			isBlocked: is("blocked"),
+			hasComment: has("a comment"),
+			hasLabel: has("a label"),
+			hasDeadline: has("a deadline"),
+			hasOwner: has("an owner"),
+			hasPr: has("a pr"),
+			hasCommit: has("a commit"),
+			hasBranch: has("a branch"),
+			hasEpic: has("an epic"),
+			hasTask: has("a task"),
+			hasAttachment: has("an attachment"),
+			created: date(),
+			updated: date(),
+			completed: date(),
+			due: date()
+		}, async ({ nextPageToken,...params }) => await tools.searchStories(params, nextPageToken));
+		server.addToolWithReadAccess("stories-get-branch-name", "Get a valid branch name for a specific story.", { storyPublicId: z.number().positive().describe("The public Id of the story") }, async ({ storyPublicId }) => await tools.getStoryBranchName(storyPublicId));
+		server.addToolWithWriteAccess("stories-create", `Create a new Shortcut story. 
+Name is required, and either a Team or Workflow must be specified:
+- If only Team is specified, we will use the default workflow for that team.
+- If Workflow is specified, it will be used regardless of Team.
+The story will be added to the default state for the workflow.
+`, {
+			name: z.string().min(1).max(512).describe("The name of the story. Required."),
+			description: z.string().max(1e4).optional().describe("The description of the story"),
+			type: z.enum([
+				"feature",
+				"bug",
+				"chore"
+			]).default("feature").describe("The type of the story"),
+			owner: z.string().optional().describe("The user id of the owner of the story"),
+			epic: z.number().optional().describe("The epic id of the epic the story belongs to"),
+			iteration: z.number().optional().describe("The iteration id of the iteration the story belongs to"),
+			team: z.string().optional().describe("The team ID or mention name of the team the story belongs to. Required unless a workflow is specified."),
+			workflow: z.number().optional().describe("The workflow ID to add the story to. Required unless a team is specified.")
+		}, async ({ name: name$1, description, type, owner, epic, iteration, team, workflow }) => await tools.createStory({
+			name: name$1,
+			description,
+			type,
+			owner,
+			epic,
+			iteration,
+			team,
+			workflow
+		}));
+		server.addToolWithWriteAccess("stories-update", "Update an existing Shortcut story. Only provide fields you want to update. The story public ID will always be included in updates.", {
+			storyPublicId: z.number().positive().describe("The public ID of the story to update"),
+			name: z.string().max(512).optional().describe("The name of the story"),
+			description: z.string().max(1e4).optional().describe("The description of the story"),
+			type: z.enum([
+				"feature",
+				"bug",
+				"chore"
+			]).optional().describe("The type of the story"),
+			epic: z.number().nullable().optional().describe("The epic id of the epic the story belongs to, or null to unset"),
+			estimate: z.number().nullable().optional().describe("The point estimate of the story, or null to unset"),
+			iteration: z.number().nullable().optional().describe("The iteration id of the iteration the story belongs to, or null to unset"),
+			owner_ids: z.array(z.string()).optional().describe("Array of user UUIDs to assign as owners of the story"),
+			workflow_state_id: z.number().optional().describe("The workflow state ID to move the story to"),
+			labels: z.array(z.object({
+				name: z.string().describe("The name of the label"),
+				color: z.string().optional().describe("The color of the label"),
+				description: z.string().optional().describe("The description of the label")
+			})).optional().describe("Labels to assign to the story")
+		}, async (params) => await tools.updateStory(params));
+		server.addToolWithWriteAccess("stories-upload-file", "Upload a file and link it to a story.", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			filePath: z.string().describe("The path to the file to upload")
+		}, async ({ storyPublicId, filePath }) => await tools.uploadFileToStory(storyPublicId, filePath));
+		server.addToolWithWriteAccess("stories-assign-current-user", "Assign the current user as the owner of a story", { storyPublicId: z.number().positive().describe("The public ID of the story") }, async ({ storyPublicId }) => await tools.assignCurrentUserAsOwner(storyPublicId));
+		server.addToolWithWriteAccess("stories-unassign-current-user", "Unassign the current user as the owner of a story", { storyPublicId: z.number().positive().describe("The public ID of the story") }, async ({ storyPublicId }) => await tools.unassignCurrentUserAsOwner(storyPublicId));
+		server.addToolWithWriteAccess("stories-create-comment", "Create a comment on a story", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			text: z.string().min(1).describe("The text of the comment")
+		}, async (params) => await tools.createStoryComment(params));
+		server.addToolWithWriteAccess("stories-create-subtask", "Create a new story as a sub-task", {
+			parentStoryPublicId: z.number().positive().describe("The public ID of the parent story"),
+			name: z.string().min(1).max(512).describe("The name of the sub-task. Required."),
+			description: z.string().max(1e4).optional().describe("The description of the sub-task")
+		}, async (params) => await tools.createSubTask(params));
+		server.addToolWithWriteAccess("stories-add-subtask", "Add an existing story as a sub-task", {
+			parentStoryPublicId: z.number().positive().describe("The public ID of the parent story"),
+			subTaskPublicId: z.number().positive().describe("The public ID of the sub-task story")
+		}, async (params) => await tools.addStoryAsSubTask(params));
+		server.addToolWithWriteAccess("stories-remove-subtask", "Remove a story from its parent. The sub-task will become a regular story.", { subTaskPublicId: z.number().positive().describe("The public ID of the sub-task story") }, async (params) => await tools.removeSubTaskFromParent(params));
+		server.addToolWithWriteAccess("stories-add-task", "Add a task to a story", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			taskDescription: z.string().min(1).describe("The description of the task"),
+			taskOwnerIds: z.array(z.string()).optional().describe("Array of user IDs to assign as owners of the task")
+		}, async (params) => await tools.addTaskToStory(params));
+		server.addToolWithWriteAccess("stories-update-task", "Update a task in a story", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			taskPublicId: z.number().positive().describe("The public ID of the task"),
+			taskDescription: z.string().optional().describe("The description of the task"),
+			taskOwnerIds: z.array(z.string()).optional().describe("Array of user IDs to assign as owners of the task"),
+			isCompleted: z.boolean().optional().describe("Whether the task is completed or not")
+		}, async (params) => await tools.updateTask(params));
+		server.addToolWithWriteAccess("stories-add-relation", "Add a story relationship to a story", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			relatedStoryPublicId: z.number().positive().describe("The public ID of the related story"),
+			relationshipType: z.enum([
+				"relates to",
+				"blocks",
+				"blocked by",
+				"duplicates",
+				"duplicated by"
+			]).optional().default("relates to").describe("The type of relationship")
+		}, async (params) => await tools.addRelationToStory(params));
+		server.addToolWithWriteAccess("stories-add-external-link", "Add an external link to a Shortcut story", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			externalLink: z.string().url().max(2048).describe("The external link URL to add")
+		}, async ({ storyPublicId, externalLink }) => await tools.addExternalLinkToStory(storyPublicId, externalLink));
+		server.addToolWithWriteAccess("stories-remove-external-link", "Remove an external link from a Shortcut story", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			externalLink: z.string().url().max(2048).describe("The external link URL to remove")
+		}, async ({ storyPublicId, externalLink }) => await tools.removeExternalLinkFromStory(storyPublicId, externalLink));
+		server.addToolWithWriteAccess("stories-set-external-links", "Replace all external links on a story with a new set of links", {
+			storyPublicId: z.number().positive().describe("The public ID of the story"),
+			externalLinks: z.array(z.string().url().max(2048)).describe("Array of external link URLs to set (replaces all existing links)")
+		}, async ({ storyPublicId, externalLinks }) => await tools.setStoryExternalLinks(storyPublicId, externalLinks));
+		server.addToolWithReadAccess("stories-get-by-external-link", "Find all stories that contain a specific external link", { externalLink: z.string().url().max(2048).describe("The external link URL to search for") }, async ({ externalLink }) => await tools.getStoriesByExternalLink(externalLink));
+		return tools;
+	}
+	async assignCurrentUserAsOwner(storyPublicId) {
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const currentUser = await this.client.getCurrentUser();
+		if (!currentUser) throw new Error("Failed to retrieve current user");
+		if (story.owner_ids.includes(currentUser.id)) return this.toResult(`Current user is already an owner of story sc-${storyPublicId}`);
+		await this.client.updateStory(storyPublicId, { owner_ids: story.owner_ids.concat([currentUser.id]) });
+		return this.toResult(`Assigned current user as owner of story sc-${storyPublicId}`);
+	}
+	async unassignCurrentUserAsOwner(storyPublicId) {
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const currentUser = await this.client.getCurrentUser();
+		if (!currentUser) throw new Error("Failed to retrieve current user");
+		if (!story.owner_ids.includes(currentUser.id)) return this.toResult(`Current user is not an owner of story sc-${storyPublicId}`);
+		await this.client.updateStory(storyPublicId, { owner_ids: story.owner_ids.filter((ownerId) => ownerId !== currentUser.id) });
+		return this.toResult(`Unassigned current user as owner of story sc-${storyPublicId}`);
+	}
+	createBranchName(currentUser, story) {
+		return `${currentUser.mention_name}/sc-${story.id}/${story.name.toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]/g, "")}`.substring(0, 50);
+	}
+	async getStoryBranchName(storyPublicId) {
+		const currentUser = await this.client.getCurrentUser();
+		if (!currentUser) throw new Error("Unable to find current user");
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const branchName = story.formatted_vcs_branch_name || this.createBranchName(currentUser, story);
+		return this.toResult(`Branch name for story sc-${storyPublicId}: ${branchName}`);
+	}
+	async createStory({ name: name$1, description, type, owner, epic, iteration, team, workflow }) {
+		if (!workflow && !team) throw new Error("Team or Workflow has to be specified");
+		if (!workflow && team) {
+			const fullTeam = await this.client.getTeam(team);
+			workflow = fullTeam?.workflow_ids?.[0];
+		}
+		if (!workflow) throw new Error("Failed to find workflow for team");
+		const fullWorkflow = await this.client.getWorkflow(workflow);
+		if (!fullWorkflow) throw new Error("Failed to find workflow");
+		const story = await this.client.createStory({
+			name: name$1,
+			description,
+			story_type: type,
+			owner_ids: owner ? [owner] : [],
+			epic_id: epic,
+			iteration_id: iteration,
+			group_id: team,
+			workflow_state_id: fullWorkflow.default_state_id
+		});
+		return this.toResult(`Created story: sc-${story.id}`);
+	}
+	async createSubTask({ parentStoryPublicId, name: name$1, description }) {
+		if (!parentStoryPublicId) throw new Error("ID of parent story is required");
+		if (!name$1) throw new Error("Sub-task name is required");
+		const parentStory = await this.client.getStory(parentStoryPublicId);
+		if (!parentStory) throw new Error(`Failed to retrieve parent story with public ID: ${parentStoryPublicId}`);
+		const workflow = await this.client.getWorkflow(parentStory.workflow_id);
+		if (!workflow) throw new Error("Failed to retrieve workflow of parent story");
+		const workflowState = workflow.states[0];
+		if (!workflowState) throw new Error("Failed to determine default state for sub-task");
+		const subTask = await this.client.createStory({
+			name: name$1,
+			description,
+			story_type: parentStory.story_type,
+			epic_id: parentStory.epic_id,
+			group_id: parentStory.group_id,
+			workflow_state_id: workflowState.id,
+			parent_story_id: parentStoryPublicId
+		});
+		return this.toResult(`Created sub-task: sc-${subTask.id}`);
+	}
+	async addStoryAsSubTask({ parentStoryPublicId, subTaskPublicId }) {
+		if (!parentStoryPublicId) throw new Error("ID of parent story is required");
+		if (!subTaskPublicId) throw new Error("ID of sub-task story is required");
+		const subTask = await this.client.getStory(subTaskPublicId);
+		if (!subTask) throw new Error(`Failed to retrieve story with public ID: ${subTaskPublicId}`);
+		const parentStory = await this.client.getStory(parentStoryPublicId);
+		if (!parentStory) throw new Error(`Failed to retrieve parent story with public ID: ${parentStoryPublicId}`);
+		await this.client.updateStory(subTaskPublicId, { parent_story_id: parentStoryPublicId });
+		return this.toResult(`Added story sc-${subTaskPublicId} as a sub-task of sc-${parentStoryPublicId}`);
+	}
+	async removeSubTaskFromParent({ subTaskPublicId }) {
+		if (!subTaskPublicId) throw new Error("ID of sub-task story is required");
+		const subTask = await this.client.getStory(subTaskPublicId);
+		if (!subTask) throw new Error(`Failed to retrieve story with public ID: ${subTaskPublicId}`);
+		await this.client.updateStory(subTaskPublicId, { parent_story_id: null });
+		return this.toResult(`Removed story sc-${subTaskPublicId} from its parent story`);
+	}
+	async searchStories(params, nextToken) {
+		const currentUser = await this.client.getCurrentUser();
+		const query = await buildSearchQuery(params, currentUser);
+		const { stories, total, next_page_token } = await this.client.searchStories(query, nextToken);
+		if (!stories) throw new Error(`Failed to search for stories matching your query: "${query}".`);
+		if (!stories.length) return this.toResult(`Result: No stories found.`);
+		return this.toResult(`Result (${stories.length} shown of ${total} total stories found):`, await this.entitiesWithRelatedEntities(stories, "stories"), next_page_token);
+	}
+	async getStory(storyPublicId, full = false) {
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}.`);
+		return this.toResult(`Story: sc-${storyPublicId}`, await this.entityWithRelatedEntities(story, "story", full));
+	}
+	async createStoryComment({ storyPublicId, text }) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!text) throw new Error("Story comment text is required");
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const storyComment = await this.client.createStoryComment(storyPublicId, { text });
+		return this.toResult(`Created comment on story sc-${storyPublicId}. Comment URL: ${storyComment.app_url}.`);
+	}
+	async updateStory({ storyPublicId,...updates }) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const updateParams = {};
+		if (updates.name !== void 0) updateParams.name = updates.name;
+		if (updates.description !== void 0) updateParams.description = updates.description;
+		if (updates.type !== void 0) updateParams.story_type = updates.type;
+		if (updates.epic !== void 0) updateParams.epic_id = updates.epic;
+		if (updates.estimate !== void 0) updateParams.estimate = updates.estimate;
+		if (updates.iteration !== void 0) updateParams.iteration_id = updates.iteration;
+		if (updates.owner_ids !== void 0) updateParams.owner_ids = updates.owner_ids;
+		if (updates.workflow_state_id !== void 0) updateParams.workflow_state_id = updates.workflow_state_id;
+		if (updates.labels !== void 0) updateParams.labels = updates.labels;
+		const updatedStory = await this.client.updateStory(storyPublicId, updateParams);
+		return this.toResult(`Updated story sc-${storyPublicId}. Story URL: ${updatedStory.app_url}`);
+	}
+	async uploadFileToStory(storyPublicId, filePath) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!filePath) throw new Error("File path is required");
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const uploadedFile = await this.client.uploadFile(storyPublicId, filePath);
+		if (!uploadedFile) throw new Error(`Failed to upload file to story sc-${storyPublicId}`);
+		return this.toResult(`Uploaded file "${uploadedFile.name}" to story sc-${storyPublicId}. File ID is: ${uploadedFile.id}`);
+	}
+	async addTaskToStory({ storyPublicId, taskDescription, taskOwnerIds }) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!taskDescription) throw new Error("Task description is required");
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		if (taskOwnerIds?.length) {
+			const owners = await this.client.getUserMap(taskOwnerIds);
+			if (!owners) throw new Error(`Failed to retrieve users with IDs: ${taskOwnerIds.join(", ")}`);
+		}
+		const task = await this.client.addTaskToStory(storyPublicId, {
+			description: taskDescription,
+			ownerIds: taskOwnerIds
+		});
+		return this.toResult(`Created task for story sc-${storyPublicId}. Task ID: ${task.id}.`);
+	}
+	async updateTask({ storyPublicId, taskPublicId, taskDescription, taskOwnerIds, isCompleted }) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!taskPublicId) throw new Error("Task public ID is required");
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const task = await this.client.getTask(storyPublicId, taskPublicId);
+		if (!task) throw new Error(`Failed to retrieve Shortcut task with public ID: ${taskPublicId}`);
+		const updatedTask = await this.client.updateTask(storyPublicId, taskPublicId, {
+			description: taskDescription,
+			ownerIds: taskOwnerIds,
+			isCompleted
+		});
+		let message = `Updated task for story sc-${storyPublicId}. Task ID: ${updatedTask.id}.`;
+		if (isCompleted) message = `Completed task for story sc-${storyPublicId}. Task ID: ${updatedTask.id}.`;
+		return this.toResult(message);
+	}
+	async addRelationToStory({ storyPublicId, relatedStoryPublicId, relationshipType }) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!relatedStoryPublicId) throw new Error("Related story public ID is required");
+		const story = await this.client.getStory(storyPublicId);
+		if (!story) throw new Error(`Failed to retrieve Shortcut story with public ID: ${storyPublicId}`);
+		const relatedStory = await this.client.getStory(relatedStoryPublicId);
+		if (!relatedStory) throw new Error(`Failed to retrieve Shortcut story with public ID: ${relatedStoryPublicId}`);
+		let subjectStoryId = storyPublicId;
+		let objectStoryId = relatedStoryPublicId;
+		if (relationshipType === "blocked by" || relationshipType === "duplicated by") {
+			relationshipType = relationshipType === "blocked by" ? "blocks" : "duplicates";
+			subjectStoryId = relatedStoryPublicId;
+			objectStoryId = storyPublicId;
+		}
+		await this.client.addRelationToStory(subjectStoryId, objectStoryId, relationshipType);
+		return this.toResult(relationshipType === "blocks" ? `Marked sc-${subjectStoryId} as a blocker to sc-${objectStoryId}.` : relationshipType === "duplicates" ? `Marked sc-${subjectStoryId} as a duplicate of sc-${objectStoryId}.` : `Added a relationship between sc-${subjectStoryId} and sc-${objectStoryId}.`);
+	}
+	async addExternalLinkToStory(storyPublicId, externalLink) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!externalLink) throw new Error("External link is required");
+		const updatedStory = await this.client.addExternalLinkToStory(storyPublicId, externalLink);
+		return this.toResult(`Added external link to story sc-${storyPublicId}. Story URL: ${updatedStory.app_url}`);
+	}
+	async removeExternalLinkFromStory(storyPublicId, externalLink) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!externalLink) throw new Error("External link is required");
+		const updatedStory = await this.client.removeExternalLinkFromStory(storyPublicId, externalLink);
+		return this.toResult(`Removed external link from story sc-${storyPublicId}. Story URL: ${updatedStory.app_url}`);
+	}
+	async getStoriesByExternalLink(externalLink) {
+		if (!externalLink) throw new Error("External link is required");
+		const { stories, total } = await this.client.getStoriesByExternalLink(externalLink);
+		if (!stories || !stories.length) return this.toResult(`No stories found with external link: ${externalLink}`);
+		return this.toResult(`Found ${total} stories with external link: ${externalLink}`, await this.entitiesWithRelatedEntities(stories, "stories"));
+	}
+	async setStoryExternalLinks(storyPublicId, externalLinks) {
+		if (!storyPublicId) throw new Error("Story public ID is required");
+		if (!Array.isArray(externalLinks)) throw new Error("External links must be an array");
+		const updatedStory = await this.client.setStoryExternalLinks(storyPublicId, externalLinks);
+		const linkCount = externalLinks.length;
+		const message = linkCount === 0 ? `Removed all external links from story sc-${storyPublicId}` : `Set ${linkCount} external link${linkCount === 1 ? "" : "s"} on story sc-${storyPublicId}`;
+		return this.toResult(`${message}. Story URL: ${updatedStory.app_url}`);
+	}
+};
+
+//#endregion
+//#region src/tools/teams.ts
+var TeamTools = class TeamTools extends BaseTools {
+	static create(client, server) {
+		const tools = new TeamTools(client);
+		server.addToolWithReadAccess("teams-get-by-id", "Get a Shortcut team by public ID", {
+			teamPublicId: z.string().describe("The public ID of the team to get"),
+			full: z.boolean().optional().default(false).describe("True to return all team fields from the API. False to return a slim version that excludes uncommon fields")
+		}, async ({ teamPublicId, full }) => await tools.getTeam(teamPublicId, full));
+		server.addToolWithReadAccess("teams-list", "List all Shortcut teams", async () => await tools.getTeams());
+		return tools;
+	}
+	async getTeam(teamPublicId, full = false) {
+		const team = await this.client.getTeam(teamPublicId);
+		if (!team) return this.toResult(`Team with public ID: ${teamPublicId} not found.`);
+		return this.toResult(`Team: ${team.id}`, await this.entityWithRelatedEntities(team, "team", full));
+	}
+	async getTeams() {
+		const teams = await this.client.getTeams();
+		if (!teams.length) return this.toResult(`No teams found.`);
+		return this.toResult(`Result (first ${teams.length} shown of ${teams.length} total teams found):`, await this.entitiesWithRelatedEntities(teams, "teams"));
+	}
+};
+
+//#endregion
+//#region src/tools/user.ts
+var UserTools = class UserTools extends BaseTools {
+	static create(client, server) {
+		const tools = new UserTools(client);
+		server.addToolWithReadAccess("users-get-current", "Get the current user", async () => await tools.getCurrentUser());
+		server.addToolWithReadAccess("users-get-current-teams", "Get a list of teams where the current user is a member", async () => await tools.getCurrentUserTeams());
+		server.addToolWithReadAccess("users-list", "Get all users", async () => await tools.listMembers());
+		return tools;
+	}
+	async getCurrentUser() {
+		const user$1 = await this.client.getCurrentUser();
+		if (!user$1) throw new Error("Failed to retrieve current user.");
+		return this.toResult(`Current user:`, user$1);
+	}
+	async getCurrentUserTeams() {
+		const teams = await this.client.getTeams();
+		const currentUser = await this.client.getCurrentUser();
+		if (!currentUser) throw new Error("Failed to get current user.");
+		const userTeams = teams.filter((team) => !team.archived && team.member_ids.includes(currentUser.id));
+		if (!userTeams.length) return this.toResult(`Current user is not a member of any teams.`);
+		if (userTeams.length === 1) {
+			const team = userTeams[0];
+			return this.toResult(`Current user is a member of team "${team.name}":`, await this.entityWithRelatedEntities(team, "team"));
+		}
+		return this.toResult(`Current user is a member of ${userTeams.length} teams:`, await this.entitiesWithRelatedEntities(userTeams, "teams"));
+	}
+	async listMembers() {
+		const members = await this.client.listMembers();
+		return this.toResult(`Found ${members.length} members:`, members);
+	}
+};
+
+//#endregion
+//#region src/tools/workflows.ts
+var WorkflowTools = class WorkflowTools extends BaseTools {
+	static create(client, server) {
+		const tools = new WorkflowTools(client);
+		server.addToolWithReadAccess("workflows-get-default", "Get the default workflow for a specific team or the global default if no team is specified.", { teamPublicId: z.string().optional().describe("The public ID of the team to get the default workflow for.") }, async ({ teamPublicId }) => await tools.getDefaultWorkflow(teamPublicId));
+		server.addToolWithReadAccess("workflows-get-by-id", "Get a Shortcut workflow by public ID", {
+			workflowPublicId: z.number().positive().describe("The public ID of the workflow to get"),
+			full: z.boolean().optional().default(false).describe("True to return all workflow fields from the API. False to return a slim version that excludes uncommon fields")
+		}, async ({ workflowPublicId, full }) => await tools.getWorkflow(workflowPublicId, full));
+		server.addToolWithReadAccess("workflows-list", "List all Shortcut workflows", async () => await tools.listWorkflows());
+		return tools;
+	}
+	async getDefaultWorkflow(teamPublicId) {
+		if (teamPublicId) try {
+			const teamDefaultWorkflowId = await this.client.getTeam(teamPublicId).then((t) => t?.default_workflow_id);
+			if (teamDefaultWorkflowId) {
+				const teamDefaultWorkflow = await this.client.getWorkflow(teamDefaultWorkflowId);
+				if (teamDefaultWorkflow) return this.toResult(`Default workflow for team "${teamPublicId}" has id ${teamDefaultWorkflow.id}.`, await this.entityWithRelatedEntities(teamDefaultWorkflow, "workflow"));
+			}
+		} catch {}
+		const currentUser = await this.client.getCurrentUser();
+		if (!currentUser) throw new Error("Failed to retrieve current user.");
+		const workspaceDefaultWorkflowId = currentUser.workspace2.default_workflow_id;
+		const workspaceDefaultWorkflow = await this.client.getWorkflow(workspaceDefaultWorkflowId);
+		if (workspaceDefaultWorkflow) return this.toResult(`${teamPublicId ? `No default workflow found for team with public ID "${teamPublicId}". The general default workflow has id ` : "Default workflow has id "}${workspaceDefaultWorkflow.id}.`, await this.entityWithRelatedEntities(workspaceDefaultWorkflow, "workflow"));
+		return this.toResult("No default workflow found.");
+	}
+	async getWorkflow(workflowPublicId, full = false) {
+		const workflow = await this.client.getWorkflow(workflowPublicId);
+		if (!workflow) return this.toResult(`Workflow with public ID: ${workflowPublicId} not found.`);
+		return this.toResult(`Workflow: ${workflow.id}`, await this.entityWithRelatedEntities(workflow, "workflow", full));
+	}
+	async listWorkflows() {
+		const workflows = await this.client.getWorkflows();
+		if (!workflows.length) return this.toResult(`No workflows found.`);
+		return this.toResult(`Result (first ${workflows.length} shown of ${workflows.length} total workflows found):`, await this.entitiesWithRelatedEntities(workflows, "workflows"));
+	}
+};
+
+//#endregion
+export { CustomMcpServer, DocumentTools, EpicTools, IterationTools, ObjectiveTools, ShortcutClientWrapper, StoryTools, TeamTools, UserTools, WorkflowTools };