@shortcut/mcp 0.7.1 → 0.8.0

package/dist/index.js

@@ -14756,6 +14756,66 @@ class ShortcutClientWrapper {
       return { iterations: null, total: null };
     return { iterations, total };
   }
+  async getActiveIteration(teamIds) {
+    const response = await this.client.listIterations();
+    const iterations = response?.data;
+    if (!iterations)
+      return new Map;
+    const [today] = 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;
+      for (const groupId of iteration.group_ids) {
+        if (!teamIds.includes(groupId))
+          continue;
+        const prevIteration = acc.get(groupId);
+        if (prevIteration) {
+          const [prevIterationEndDate] = new Date(prevIteration.end_date).toISOString().split("T");
+          if (endDate < prevIterationEndDate)
+            acc.set(groupId, iteration);
+        } else
+          acc.set(groupId, iteration);
+      }
+      return acc;
+    }, new Map);
+    return activeIterationByTeam;
+  }
+  async getUpcomingIteration(teamIds) {
+    const response = await this.client.listIterations();
+    const iterations = response?.data;
+    if (!iterations)
+      return new Map;
+    const [today] = 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;
+      for (const groupId of iteration.group_ids) {
+        if (!teamIds.includes(groupId))
+          continue;
+        const prevIteration = acc.get(groupId);
+        if (prevIteration) {
+          const [prevIterationEndDate] = new Date(prevIteration.end_date).toISOString().split("T");
+          if (endDate < prevIterationEndDate)
+            acc.set(groupId, iteration);
+        } else
+          acc.set(groupId, iteration);
+      }
+      return acc;
+    }, new Map);
+    return upcomingIterationByTeam;
+  }
   async searchEpics(query) {
     const response = await this.client.searchEpics({ query, page_size: 25, detail: "full" });
     const epics = response?.data?.data;
@@ -14772,9 +14832,9 @@ class ShortcutClientWrapper {
       return { milestones: null, total: null };
     return { milestones, total };
   }
-  async listIterationStories(iterationPublicId) {
+  async listIterationStories(iterationPublicId, includeDescription = false) {
     const response = await this.client.listIterationStories(iterationPublicId, {
-      includes_description: true
+      includes_description: includeDescription
     });
     const stories = response?.data;
     if (!stories)
@@ -14845,6 +14905,37 @@ class ShortcutClientWrapper {
       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 });
+  }
 }
 
 // node_modules/zod/lib/index.mjs
@@ -21578,7 +21669,7 @@ var import_client = __toESM(require_lib(), 1);
 
 // package.json
 var name = "@shortcut/mcp";
-var version = "0.7.1";
+var version = "0.8.0";
 
 // src/tools/base.ts
 class BaseTools {
@@ -21586,99 +21677,215 @@ class BaseTools {
   constructor(client) {
     this.client = client;
   }
-  async correctMember(entity) {
+  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: { name: name2, email_address, mention_name }
+      profile: { is_owner, name: name2, email_address, mention_name }
     } = entity;
-    return { id, name: name2, email_address, mention_name, role, disabled };
+    return { id, name: name2, email_address, mention_name, role, disabled, is_owner };
   }
-  async correctWorkflow(entity) {
+  getSimplifiedWorkflow(entity) {
     if (!entity)
       return null;
-    const { team_id, ...withoutTeam } = entity;
-    return { ...withoutTeam };
+    const { id, name: name2, states } = entity;
+    return { id, name: name2, states: states.map((state) => ({ id: state.id, name: state.name })) };
   }
-  async correctTeam(entity) {
+  getSimplifiedTeam(entity) {
     if (!entity)
       return null;
-    const { member_ids, workflow_ids, ...withoutIds } = entity;
-    const users = await this.client.getUserMap(member_ids);
-    const workflows = await this.client.getWorkflowMap(workflow_ids);
-    const correctedEntity = {
-      ...withoutIds,
-      members: await Promise.all(member_ids.map((id) => this.correctMember(users.get(id))).filter(Boolean)),
-      workflows: await Promise.all(workflow_ids.map((id) => this.correctWorkflow(workflows.get(id))).filter(Boolean))
+    const { archived, id, name: name2, mention_name, member_ids, workflow_ids } = entity;
+    return { id, name: name2, archived, mention_name, member_ids, workflow_ids };
+  }
+  getSimplifiedObjective(entity) {
+    if (!entity)
+      return null;
+    const { app_url, id, name: name2, archived, state, categories } = entity;
+    return { app_url, id, name: name2, archived, state, categories: categories.map((cat) => cat.name) };
+  }
+  getSimplifiedEpic(entity) {
+    if (!entity)
+      return null;
+    const { id, name: name2, app_url, archived, group_id, state, milestone_id } = entity;
+    return {
+      id,
+      name: name2,
+      app_url,
+      archived,
+      state,
+      team_id: group_id || null,
+      objective_id: milestone_id || null
     };
-    return correctedEntity;
   }
-  async correctIteration(entity) {
+  getSimplifiedIteration(entity) {
     if (!entity)
       return null;
-    const { group_ids, ...withoutGroupIds } = entity;
-    const teams = await this.client.getTeamMap(group_ids?.filter(Boolean));
-    const correctedEntity = {
-      ...withoutGroupIds,
-      teams: await Promise.all(group_ids?.map((id) => this.correctTeam(teams.get(id)))?.filter(Boolean) ?? [])
+    const { id, name: name2, app_url, group_ids, status } = entity;
+    return { id, name: name2, app_url, team_ids: group_ids, status };
+  }
+  async getRelatedEntitiesForTeam(entity) {
+    if (!entity)
+      return { users: {}, workflows: {} };
+    const { member_ids, workflow_ids } = entity;
+    const users = await this.client.getUserMap(member_ids);
+    const workflows = await 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]))
     };
-    return correctedEntity;
   }
-  async correctMilestone(entity) {
-    return entity;
+  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 correctEpic(entity) {
-    const { group_id, owner_ids, requested_by_id, follower_ids, ...withoutIds } = entity;
-    const users = await this.client.getUserMap([
-      ...new Set([...owner_ids, requested_by_id, ...follower_ids])
+  async getRelatedEntitiesForEpic(entity) {
+    if (!entity)
+      return { users: {}, workflows: {}, teams: {}, objectives: {} };
+    const { group_id, owner_ids, milestone_id, requested_by_id, follower_ids } = entity;
+    const usersForEpicMap = await this.client.getUserMap([
+      ...new Set([...owner_ids || [], requested_by_id, ...follower_ids || []].filter(Boolean))
     ]);
+    const usersForEpic = Object.fromEntries(usersForEpicMap.entries().filter(([_, user]) => !!user).map(([id, user]) => [id, this.getSimplifiedMember(user)]));
     const teams = await this.client.getTeamMap(group_id ? [group_id] : []);
-    const correctedEntity = {
-      ...withoutIds,
-      owners: (await Promise.all(owner_ids?.map((id) => this.correctMember(users.get(id))))).filter(Boolean) ?? [],
-      requested_by: requested_by_id ? await this.correctMember(users.get(requested_by_id)) : null,
-      followers: (await Promise.all(follower_ids?.map((id) => this.correctMember(users.get(id))))).filter(Boolean) ?? [],
-      team: group_id ? await this.correctTeam(teams.get(group_id)) : null
+    const team = this.getSimplifiedTeam(teams.get(group_id || ""));
+    const { users, workflows } = await this.getRelatedEntitiesForTeam(teams.get(group_id || ""));
+    const milestone = this.getSimplifiedObjective(milestone_id ? await this.client.getMilestone(milestone_id) : null);
+    return {
+      users: this.mergeRelatedEntities([usersForEpic, users]),
+      teams: team ? { [team.id]: team } : {},
+      objectives: milestone ? { [milestone.id]: milestone } : {},
+      workflows
     };
-    return correctedEntity;
   }
-  async correctStory(entity) {
-    const { group_id, owner_ids, requested_by_id, follower_ids, workflow_id, ...withoutIds } = entity;
-    const users = await this.client.getUserMap([
-      ...new Set([...owner_ids, requested_by_id, ...follower_ids])
+  async getRelatedEntitiesForStory(entity) {
+    const {
+      group_id,
+      iteration_id,
+      epic_id,
+      owner_ids,
+      requested_by_id,
+      follower_ids,
+      workflow_id
+    } = entity;
+    const fullUsersForStory = await this.client.getUserMap([
+      ...new Set([...owner_ids || [], requested_by_id, ...follower_ids || []].filter(Boolean))
     ]);
-    const teams = await this.client.getTeamMap(group_id ? [group_id] : []);
-    const workflows = await this.client.getWorkflowMap(workflow_id ? [workflow_id] : []);
-    const correctedEntity = {
-      ...withoutIds,
-      owners: (await Promise.all(owner_ids?.map((id) => this.correctMember(users.get(id)))))?.filter(Boolean) ?? [],
-      requested_by: requested_by_id ? await this.correctMember(users.get(requested_by_id)) : null,
-      followers: (await Promise.all(follower_ids?.map((id) => this.correctMember(users.get(id)))))?.filter(Boolean) ?? [],
-      team: group_id ? await this.correctTeam(teams.get(group_id)) : null,
-      workflow: workflow_id ? await this.correctWorkflow(workflows.get(workflow_id)) : null
+    const usersForStory = Object.fromEntries(fullUsersForStory.entries().filter(([_, user]) => !!user).map(([id, user]) => [id, this.getSimplifiedMember(user)]));
+    const teamsForStory = await this.client.getTeamMap(group_id ? [group_id] : []);
+    const workflowsForStory = await this.client.getWorkflowMap(workflow_id ? [workflow_id] : []);
+    const iteration = iteration_id ? await this.client.getIteration(iteration_id) : null;
+    const simplifiedIteration = this.getSimplifiedIteration(iteration);
+    const epic = epic_id ? await this.client.getEpic(epic_id) : null;
+    const simplifiedEpic = this.getSimplifiedEpic(epic);
+    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 teams = this.mergeRelatedEntities([
+      teamsForIteration,
+      teamsForEpic,
+      teamForStory ? { [teamForStory.id]: teamForStory } : {}
+    ]);
+    const epics = simplifiedEpic ? { [simplifiedEpic.id]: simplifiedEpic } : {};
+    const iterations = simplifiedIteration ? { [simplifiedIteration.id]: simplifiedIteration } : {};
+    return {
+      users,
+      epics,
+      iterations,
+      workflows,
+      teams,
+      objectives
     };
-    return correctedEntity;
   }
-  async toCorrectedEntity(entity) {
-    if (entity.entity_type === "workflow")
-      return this.correctWorkflow(entity);
+  async getRelatedEntities(entity) {
     if (entity.entity_type === "group")
-      return this.correctTeam(entity);
+      return this.getRelatedEntitiesForTeam(entity);
     if (entity.entity_type === "iteration")
-      return this.correctIteration(entity);
-    if (entity.entity_type === "milestone")
-      return this.correctMilestone(entity);
+      return this.getRelatedEntitiesForIteration(entity);
     if (entity.entity_type === "epic")
-      return this.correctEpic(entity);
+      return this.getRelatedEntitiesForEpic(entity);
     if (entity.entity_type === "story")
-      return this.correctStory(entity);
-    return entity;
+      return this.getRelatedEntitiesForStory(entity);
+    return {};
   }
-  async toCorrectedEntities(entities) {
-    return Promise.all(entities.map((entity) => this.toCorrectedEntity(entity)));
+  async entityWithRelatedEntities(entity, entityType = "entity") {
+    const relatedEntities = await this.getRelatedEntities(entity);
+    return {
+      [entityType]: this.renameEntityProps(entity),
+      relatedEntities
+    };
+  }
+  async entitiesWithRelatedEntities(entities, entityType = "entities") {
+    const relatedEntities = await Promise.all(entities.map((entity) => this.getRelatedEntities(entity)));
+    return {
+      [entityType]: entities.map((entity) => this.renameEntityProps(entity)),
+      relatedEntities: this.mergeRelatedEntities(relatedEntities)
+    };
   }
   toResult(message, data) {
     return {
@@ -21798,13 +22005,13 @@ class EpicTools extends BaseTools {
       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 (first ${epics.length} shown of ${total} total epics found):`, await this.toCorrectedEntities(epics));
+    return this.toResult(`Result (first ${epics.length} shown of ${total} total epics found):`, await this.entitiesWithRelatedEntities(epics, "epics"));
   }
   async getEpic(epicPublicId) {
     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.toCorrectedEntity(epic));
+    return this.toResult(`Epic: ${epicPublicId}`, await this.entityWithRelatedEntities(epic, "epic"));
   }
   async createEpic({
     name: name2,
@@ -21826,7 +22033,10 @@ class EpicTools extends BaseTools {
 class IterationTools extends BaseTools {
   static create(client, server) {
     const tools = new IterationTools(client);
-    server.tool("get-iteration-stories", "Get stories in a specific iteration by iteration public ID", { iterationPublicId: z.number().positive().describe("The public ID of the iteration") }, async ({ iterationPublicId }) => await tools.getIterationStories(iterationPublicId));
+    server.tool("get-iteration-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.tool("get-iteration", "Get a Shortcut iteration by public ID", {
       iterationPublicId: z.number().positive().describe("The public ID of the iteration to get")
     }, async ({ iterationPublicId }) => await tools.getIteration(iterationPublicId));
@@ -21848,13 +22058,19 @@ class IterationTools extends BaseTools {
       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.tool("get-active-iterations", "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.tool("get-upcoming-iterations", "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) {
-    const { stories } = await this.client.listIterationStories(iterationPublicId);
+  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.toCorrectedEntities(stories));
+    return this.toResult(`Result (${stories.length} stories found):`, await this.entitiesWithRelatedEntities(stories, "stories"));
   }
   async searchIterations(params) {
     const currentUser = await this.client.getCurrentUser();
@@ -21864,13 +22080,13 @@ class IterationTools extends BaseTools {
       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 (first ${iterations.length} shown of ${total} total iterations found):`, await this.toCorrectedEntities(iterations));
+    return this.toResult(`Result (first ${iterations.length} shown of ${total} total iterations found):`, await this.entitiesWithRelatedEntities(iterations, "iterations"));
   }
   async getIteration(iterationPublicId) {
     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.toCorrectedEntity(iteration));
+    return this.toResult(`Iteration: ${iterationPublicId}`, await this.entityWithRelatedEntities(iteration, "iteration"));
   }
   async createIteration({
     name: name2,
@@ -21890,6 +22106,54 @@ class IterationTools extends BaseTools {
       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 iteration = result.get(teamId);
+      if (!iteration)
+        return this.toResult(`Result: No active iterations found for team.`);
+      return this.toResult("The active iteration for the team is:", await this.entityWithRelatedEntities(iteration, "iteration"));
+    }
+    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()];
+    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 iteration = result.get(teamId);
+      if (!iteration)
+        return this.toResult(`Result: No upcoming iterations found for team.`);
+      return this.toResult("The next upcoming iteration for the team is:", await this.entityWithRelatedEntities(iteration, "iteration"));
+    }
+    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()];
+    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"));
+  }
 }
 
 // src/tools/objectives.ts
@@ -21926,13 +22190,13 @@ class ObjectiveTools extends BaseTools {
       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 (first ${milestones.length} shown of ${total} total milestones found):`, await this.toCorrectedEntities(milestones));
+    return this.toResult(`Result (first ${milestones.length} shown of ${total} total milestones found):`, await this.entitiesWithRelatedEntities(milestones, "objectives"));
   }
   async getObjective(objectivePublicId) {
     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.toCorrectedEntity(objective));
+    return this.toResult(`Objective: ${objectivePublicId}`, await this.entityWithRelatedEntities(objective, "objective"));
   }
 }
 
@@ -22056,6 +22320,21 @@ The story will be added to the default state for the workflow.
       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.tool("add-external-link-to-story", "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.tool("remove-external-link-from-story", "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.tool("get-stories-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));
+    server.tool("set-story-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));
     return tools;
   }
   async assignCurrentUserAsOwner(storyPublicId) {
@@ -22138,13 +22417,13 @@ The story will be added to the default state for the workflow.
       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 (first ${stories.length} shown of ${total} total stories found):`, await this.toCorrectedEntities(stories));
+    return this.toResult(`Result (first ${stories.length} shown of ${total} total stories found):`, await this.entitiesWithRelatedEntities(stories, "stories"));
   }
   async getStory(storyPublicId) {
     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.toCorrectedEntity(story));
+    return this.toResult(`Story: sc-${storyPublicId}`, await this.entityWithRelatedEntities(story, "story"));
   }
   async createStoryComment({
     storyPublicId,
@@ -22265,6 +22544,41 @@ The story will be added to the default state for the workflow.
     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}`);
+  }
 }
 
 // src/tools/teams.ts
@@ -22279,13 +22593,13 @@ class TeamTools extends BaseTools {
     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.toCorrectedEntity(team));
+    return this.toResult(`Team: ${team.id}`, await this.entityWithRelatedEntities(team, "team"));
   }
   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.toCorrectedEntities(teams));
+    return this.toResult(`Result (first ${teams.length} shown of ${teams.length} total teams found):`, await this.entitiesWithRelatedEntities(teams, "teams"));
   }
 }
 
@@ -22321,13 +22635,13 @@ class WorkflowTools extends BaseTools {
     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.toCorrectedEntity(workflow));
+    return this.toResult(`Workflow: ${workflow.id}`, await this.entityWithRelatedEntities(workflow, "workflow"));
   }
   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.toCorrectedEntities(workflows));
+    return this.toResult(`Result (first ${workflows.length} shown of ${workflows.length} total workflows found):`, await this.entitiesWithRelatedEntities(workflows, "workflows"));
   }
 }
 

package/package.json

@@ -12,7 +12,7 @@
 		"modelcontextprotocol"
 	],
 	"license": "MIT",
-	"version": "0.7.1",
+	"version": "0.8.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {