@schoolai/shipyard 1.2.0 → 2.0.0

package/dist/plugin-mcp-linear.js

@@ -0,0 +1,1683 @@
+#!/usr/bin/env node
+
+// ../../packages/linear-plugin/dist/mcp.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var LINEAR_API_URL = "https://api.linear.app/graphql";
+function parseErrorBody(body) {
+  if (!body) return "";
+  try {
+    const parsed = JSON.parse(
+      body
+    );
+    if (parsed.errors) {
+      return `: ${parsed.errors.map((e) => e.message).join("; ")}`;
+    }
+    if (parsed.error) {
+      return `: ${parsed.error}`;
+    }
+    return `: ${body}`;
+  } catch {
+    return `: ${body}`;
+  }
+}
+async function readErrorResponse(response) {
+  const rateLimitReset = response.headers.get("X-RateLimit-Requests-Reset");
+  if (response.status === 429 && rateLimitReset) {
+    return `Linear API rate limited. Resets at ${rateLimitReset}. Please wait before retrying.`;
+  }
+  let body = "";
+  try {
+    body = await response.text();
+  } catch {
+  }
+  const detail = parseErrorBody(body);
+  return `Linear API request failed (${response.status} ${response.statusText})${detail}`;
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var LinearGraphQLClient = class {
+  #token;
+  constructor(token) {
+    this.#token = token;
+  }
+  async query(document, variables) {
+    const cleanedVariables = variables ? stripUndefined(variables) : void 0;
+    const response = await fetch(LINEAR_API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: this.#token
+      },
+      body: JSON.stringify({ query: document, variables: cleanedVariables })
+    });
+    if (!response.ok) {
+      throw new Error(await readErrorResponse(response));
+    }
+    const json = await response.json();
+    if (json.errors && json.errors.length > 0) {
+      const messages = json.errors.map((e) => {
+        const ext = e.extensions ? ` (${JSON.stringify(e.extensions)})` : "";
+        return `${e.message}${ext}`;
+      }).join("; ");
+      throw new Error(`Linear GraphQL error: ${messages}`);
+    }
+    if (!json.data) {
+      throw new Error("Linear API returned no data");
+    }
+    return json.data;
+  }
+};
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(value) {
+  return UUID_RE.test(value);
+}
+var TEAM_KEY_RE = /^[A-Za-z]{1,10}$/;
+async function resolveTeamId(client, teamIdOrKey) {
+  if (isUUID(teamIdOrKey)) return teamIdOrKey;
+  if (TEAM_KEY_RE.test(teamIdOrKey)) {
+    const data = await client.query(
+      `query($filter: TeamFilter, $first: Int) {
+        teams(filter: $filter, first: $first) {
+          nodes { id key }
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+        }
+      }`,
+      { filter: { key: { eq: teamIdOrKey.toUpperCase() } }, first: 1 }
+    );
+    const match = data.teams.nodes[0];
+    if (match) return match.id;
+  }
+  throw new Error(`Could not resolve team "${teamIdOrKey}". Use a UUID or team key like "ENG".`);
+}
+function formatConnection(connection, formatNode) {
+  const lines = connection.nodes.map(formatNode);
+  const pagination = [];
+  if (connection.pageInfo.hasNextPage) {
+    pagination.push(`Next page cursor: ${connection.pageInfo.endCursor}`);
+  }
+  if (connection.pageInfo.hasPreviousPage) {
+    pagination.push(`Previous page cursor: ${connection.pageInfo.startCursor}`);
+  }
+  if (pagination.length > 0) {
+    lines.push("", "---", ...pagination);
+  }
+  return lines.join("\n");
+}
+var ISSUE_IDENTIFIER_RE = /^[A-Za-z]+-\d+$/;
+async function resolveIssueIdForComments(client, idOrIdentifier) {
+  if (isUUID(idOrIdentifier)) return idOrIdentifier;
+  if (ISSUE_IDENTIFIER_RE.test(idOrIdentifier)) {
+    const data = await client.query(
+      `query($term: String!, $first: Int) {
+        searchIssues(term: $term, first: $first) {
+          nodes { id identifier }
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+        }
+      }`,
+      { term: idOrIdentifier.toUpperCase(), first: 5 }
+    );
+    const match = data.searchIssues.nodes.find(
+      (n) => n.identifier.toUpperCase() === idOrIdentifier.toUpperCase()
+    );
+    if (match) return match.id;
+  }
+  throw new Error(
+    `Could not resolve issue "${idOrIdentifier}". Use a UUID or identifier like "ENG-123".`
+  );
+}
+async function listComments(client, params) {
+  const issueId = await resolveIssueIdForComments(client, params.issueId);
+  const data = await client.query(
+    `query($id: String!) {
+      issue(id: $id) {
+        identifier title
+        comments {
+          nodes {
+            id body createdAt updatedAt
+            user { id name email }
+          }
+        }
+      }
+    }`,
+    { id: issueId }
+  );
+  const { issue } = data;
+  if (issue.comments.nodes.length === 0) {
+    return `No comments on ${issue.identifier}: ${issue.title}`;
+  }
+  const lines = [`# Comments on ${issue.identifier}: ${issue.title}`, ""];
+  for (const comment of issue.comments.nodes) {
+    const author = comment.user ? comment.user.name : "Unknown";
+    lines.push(`**${author}** (${comment.createdAt}) [ID: ${comment.id}]:`);
+    lines.push(comment.body, "");
+  }
+  return lines.join("\n");
+}
+async function createComment(client, params) {
+  const issueId = await resolveIssueIdForComments(client, params.issueId);
+  const data = await client.query(
+    `mutation($input: CommentCreateInput!) {
+      commentCreate(input: $input) {
+        success
+        comment {
+          id body
+          issue { identifier }
+        }
+      }
+    }`,
+    { input: { issueId, body: params.body } }
+  );
+  const comment = data.commentCreate.comment;
+  return `Comment added to ${comment.issue.identifier}
+ID: ${comment.id}`;
+}
+async function deleteComment(client, params) {
+  const data = await client.query(
+    `mutation($id: String!) {
+      commentDelete(id: $id) { success }
+    }`,
+    { id: params.id }
+  );
+  if (!data.commentDelete.success) {
+    throw new Error(`Failed to delete comment "${params.id}".`);
+  }
+  return `Deleted comment ${params.id}.`;
+}
+var DOCUMENT_FIELDS = `
+  id title icon color url createdAt updatedAt
+  creator { id name }
+  project { id name }
+`;
+function formatDocSummary(doc) {
+  const creator = doc.creator ? ` | By: ${doc.creator.name}` : "";
+  const project = doc.project ? ` | Project: ${doc.project.name}` : "";
+  return `${doc.title}${creator}${project}
+  URL: ${doc.url} | ID: ${doc.id}`;
+}
+async function getDocument(client, params) {
+  const data = await client.query(
+    `query($id: String!) {
+      document(id: $id) {
+        ${DOCUMENT_FIELDS}
+        content
+      }
+    }`,
+    { id: params.id }
+  );
+  const doc = data.document;
+  const lines = [`# ${doc.title}`, "", `**URL:** ${doc.url}`, `**ID:** ${doc.id}`];
+  if (doc.creator) lines.push(`**Creator:** ${doc.creator.name}`);
+  if (doc.project) lines.push(`**Project:** ${doc.project.name}`);
+  lines.push(`**Created:** ${doc.createdAt}`, `**Updated:** ${doc.updatedAt}`);
+  if (doc.content) {
+    lines.push("", "---", "", doc.content);
+  }
+  return lines.join("\n");
+}
+var VALID_PAGINATION_ORDER_BY = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+function normalizeOrderBy(orderBy) {
+  if (!orderBy) return void 0;
+  if (VALID_PAGINATION_ORDER_BY.has(orderBy)) return orderBy;
+  return void 0;
+}
+async function listDocuments(client, params) {
+  const limit = params.limit ?? 25;
+  const filter = {};
+  if (params.query) filter.title = { containsIgnoreCase: params.query };
+  if (params.projectId) filter.project = { id: { eq: params.projectId } };
+  if (params.creatorId) filter.creator = { id: { eq: params.creatorId } };
+  if (params.createdAt) filter.createdAt = { gte: params.createdAt };
+  if (params.updatedAt) filter.updatedAt = { gte: params.updatedAt };
+  const data = await client.query(
+    `query($filter: DocumentFilter, $first: Int, $after: String, $before: String, $includeArchived: Boolean, $orderBy: PaginationOrderBy) {
+      documents(filter: $filter, first: $first, after: $after, before: $before, includeArchived: $includeArchived, orderBy: $orderBy) {
+        nodes { ${DOCUMENT_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    {
+      filter: Object.keys(filter).length > 0 ? filter : void 0,
+      first: limit,
+      after: params.after,
+      before: params.before,
+      includeArchived: params.includeArchived,
+      orderBy: normalizeOrderBy(params.orderBy)
+    }
+  );
+  if (data.documents.nodes.length === 0) {
+    return "No documents found.";
+  }
+  return formatConnection(data.documents, formatDocSummary);
+}
+async function searchDocumentation(_client, params) {
+  const page = params.page ?? 1;
+  const response = await fetch(
+    `https://linear.app/docs/api/search?q=${encodeURIComponent(params.query)}&page=${page}`
+  );
+  if (!response.ok) {
+    return `Linear documentation search is not available via this server. Use https://linear.app/docs and search for: ${params.query}`;
+  }
+  const text = await response.text();
+  return text || `No documentation results found for: ${params.query}`;
+}
+var ISSUE_IDENTIFIER_RE2 = /^[A-Za-z]+-\d+$/;
+var ISSUE_FIELDS = `
+  id identifier title description priority priorityLabel url branchName
+  createdAt updatedAt dueDate estimate
+  state { id name type }
+  team { id key name }
+  assignee { id name email }
+  project { id name }
+  parent { id identifier title }
+  labels { nodes { id name } }
+`;
+var ISSUE_DETAIL_FIELDS = `
+  ${ISSUE_FIELDS}
+  attachments { nodes { id title url } }
+  comments { nodes { id body createdAt user { name } } }
+`;
+var ISSUE_LIST_FIELDS = `
+  id identifier title priority priorityLabel url
+  createdAt updatedAt dueDate
+  state { id name type }
+  team { id key name }
+  assignee { id name email }
+  project { id name }
+  labels { nodes { id name } }
+`;
+function formatIssueSummary(issue) {
+  const assignee = issue.assignee ? ` | Assignee: ${issue.assignee.name}` : "";
+  const labels = issue.labels.nodes.length > 0 ? ` | Labels: ${issue.labels.nodes.map((l) => l.name).join(", ")}` : "";
+  return `[${issue.identifier}] ${issue.title} (${issue.state.name}, ${issue.priorityLabel})${assignee}${labels}
+  URL: ${issue.url}`;
+}
+function formatIssueMetadata(issue) {
+  const lines = [
+    `# ${issue.identifier}: ${issue.title}`,
+    "",
+    `**Status:** ${issue.state.name} (${issue.state.type})`,
+    `**Priority:** ${issue.priorityLabel}`,
+    `**Team:** ${issue.team.name} (${issue.team.key})`
+  ];
+  if (issue.assignee) lines.push(`**Assignee:** ${issue.assignee.name} (${issue.assignee.email})`);
+  if (issue.project) lines.push(`**Project:** ${issue.project.name}`);
+  if (issue.parent) lines.push(`**Parent:** ${issue.parent.identifier} - ${issue.parent.title}`);
+  if (issue.dueDate) lines.push(`**Due:** ${issue.dueDate}`);
+  if (issue.estimate !== void 0) lines.push(`**Estimate:** ${issue.estimate}`);
+  if (issue.labels.nodes.length > 0) {
+    lines.push(`**Labels:** ${issue.labels.nodes.map((l) => l.name).join(", ")}`);
+  }
+  lines.push(`**URL:** ${issue.url}`, `**ID:** ${issue.id}`);
+  return lines;
+}
+function formatIssueDetail(issue) {
+  const lines = formatIssueMetadata(issue);
+  if (issue.description) {
+    lines.push("", "## Description", "", issue.description);
+  }
+  if (issue.attachments.nodes.length > 0) {
+    lines.push("", "## Attachments");
+    for (const a of issue.attachments.nodes) {
+      lines.push(`- [${a.title}](${a.url})`);
+    }
+  }
+  if (issue.comments.nodes.length > 0) {
+    lines.push("", "## Comments");
+    for (const c of issue.comments.nodes) {
+      const author = c.user ? c.user.name : "Unknown";
+      lines.push("", `**${author}** (${c.createdAt}) [ID: ${c.id}]:`, c.body);
+    }
+  }
+  return lines.join("\n");
+}
+async function resolveAssigneeId(client, assigneeId) {
+  if (assigneeId === "me") {
+    const viewer = await client.query(`query { viewer { id } }`);
+    return viewer.viewer.id;
+  }
+  return assigneeId;
+}
+var VALID_PAGINATION_ORDER_BY2 = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+function normalizeOrderBy2(orderBy) {
+  if (!orderBy) return void 0;
+  if (VALID_PAGINATION_ORDER_BY2.has(orderBy)) return orderBy;
+  return void 0;
+}
+async function listIssues(client, params) {
+  const limit = Math.min(params.limit ?? 25, 100);
+  const validOrderBy = normalizeOrderBy2(params.orderBy);
+  const [teamId, assigneeId] = await Promise.all([
+    params.teamId ? resolveTeamId(client, params.teamId) : Promise.resolve(void 0),
+    resolveAssigneeId(client, params.assigneeId)
+  ]);
+  if (params.query) {
+    const data2 = await client.query(
+      `query($term: String!, $first: Int, $includeArchived: Boolean) {
+        searchIssues(term: $term, first: $first, includeArchived: $includeArchived) {
+          nodes { ${ISSUE_LIST_FIELDS} }
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+        }
+      }`,
+      {
+        term: params.query,
+        first: limit,
+        includeArchived: params.includeArchived
+      }
+    );
+    return formatConnection(data2.searchIssues, formatIssueSummary);
+  }
+  const filter = buildIssueFilter({ ...params, teamId, assigneeId });
+  const data = await client.query(
+    `query($filter: IssueFilter, $first: Int, $after: String, $includeArchived: Boolean, $orderBy: PaginationOrderBy) {
+      issues(filter: $filter, first: $first, after: $after, includeArchived: $includeArchived, orderBy: $orderBy) {
+        nodes { ${ISSUE_LIST_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    {
+      filter: Object.keys(filter).length > 0 ? filter : void 0,
+      first: limit,
+      after: params.after,
+      includeArchived: params.includeArchived,
+      orderBy: validOrderBy
+    }
+  );
+  return formatConnection(data.issues, formatIssueSummary);
+}
+function buildIssueFilter(params) {
+  const filter = {};
+  if (params.teamId) filter.team = { id: { eq: params.teamId } };
+  if (params.stateId) filter.state = { id: { eq: params.stateId } };
+  if (params.assigneeId) filter.assignee = { id: { eq: params.assigneeId } };
+  if (params.parentId) filter.parent = { id: { eq: params.parentId } };
+  if (params.projectId) filter.project = { id: { eq: params.projectId } };
+  if (params.createdAt) filter.createdAt = { gte: params.createdAt };
+  if (params.updatedAt) filter.updatedAt = { gte: params.updatedAt };
+  return filter;
+}
+async function getIssue(client, params) {
+  if (isUUID(params.id)) {
+    const data = await client.query(
+      `query($id: String!) {
+        issue(id: $id) { ${ISSUE_DETAIL_FIELDS} }
+      }`,
+      { id: params.id }
+    );
+    return formatIssueDetail(data.issue);
+  }
+  if (ISSUE_IDENTIFIER_RE2.test(params.id)) {
+    const searchData2 = await client.query(
+      `query($term: String!, $first: Int) {
+        searchIssues(term: $term, first: $first) {
+          nodes { ${ISSUE_DETAIL_FIELDS} }
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+        }
+      }`,
+      { term: params.id.toUpperCase(), first: 5 }
+    );
+    const match = searchData2.searchIssues.nodes.find(
+      (n) => n.identifier.toUpperCase() === params.id.toUpperCase()
+    );
+    if (match) {
+      return formatIssueDetail(match);
+    }
+  }
+  const searchData = await client.query(
+    `query($term: String!, $first: Int) {
+      searchIssues(term: $term, first: $first) {
+        nodes { ${ISSUE_DETAIL_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { term: params.id, first: 1 }
+  );
+  const first = searchData.searchIssues.nodes[0];
+  if (!first) {
+    throw new Error(
+      `Issue not found: "${params.id}". Try using a UUID, an identifier like "ENG-123", or a search term.`
+    );
+  }
+  return formatIssueDetail(first);
+}
+async function createIssue(client, params) {
+  const [teamId, assigneeId] = await Promise.all([
+    resolveTeamId(client, params.teamId),
+    resolveAssigneeId(client, params.assigneeId)
+  ]);
+  const input = {
+    title: params.title,
+    teamId
+  };
+  if (params.description !== void 0) input.description = params.description;
+  if (params.priority !== void 0) input.priority = params.priority;
+  if (params.projectId) input.projectId = params.projectId;
+  if (params.parentId) input.parentId = params.parentId;
+  if (params.stateId) input.stateId = params.stateId;
+  if (assigneeId) input.assigneeId = assigneeId;
+  if (params.labelIds) input.labelIds = params.labelIds;
+  if (params.dueDate) input.dueDate = params.dueDate;
+  const data = await client.query(
+    `mutation($input: IssueCreateInput!) {
+      issueCreate(input: $input) {
+        success
+        issue {
+          id identifier title url
+          state { name }
+          team { key }
+        }
+      }
+    }`,
+    { input }
+  );
+  const issue = data.issueCreate.issue;
+  return `Created issue ${issue.identifier}: ${issue.title}
+Status: ${issue.state.name}
+URL: ${issue.url}
+ID: ${issue.id}`;
+}
+async function updateIssue(client, params) {
+  const resolvedId = await resolveIssueId(client, params.id);
+  const resolvedAssignee = await resolveAssigneeId(client, params.assigneeId);
+  const { id: _id, assigneeId: _assigneeId, ...rest } = params;
+  const input = {};
+  for (const [key, value] of Object.entries(rest)) {
+    if (value !== void 0) {
+      input[key] = value;
+    }
+  }
+  if (resolvedAssignee !== void 0) input.assigneeId = resolvedAssignee;
+  const data = await client.query(
+    `mutation($id: String!, $input: IssueUpdateInput!) {
+      issueUpdate(id: $id, input: $input) {
+        success
+        issue {
+          id identifier title url
+          state { name }
+        }
+      }
+    }`,
+    { id: resolvedId, input }
+  );
+  const issue = data.issueUpdate.issue;
+  return `Updated issue ${issue.identifier}: ${issue.title}
+Status: ${issue.state.name}
+URL: ${issue.url}`;
+}
+async function deleteIssue(client, params) {
+  const resolvedId = await resolveIssueId(client, params.id);
+  const data = await client.query(
+    `mutation($id: String!) {
+      issueDelete(id: $id) { success }
+    }`,
+    { id: resolvedId }
+  );
+  if (!data.issueDelete.success) {
+    throw new Error(`Failed to delete issue "${params.id}".`);
+  }
+  return `Deleted issue ${params.id}.`;
+}
+async function listMyIssues(client, params) {
+  const limit = params.limit ?? 25;
+  const validOrderBy = normalizeOrderBy2(params.orderBy);
+  const data = await client.query(
+    `query($first: Int, $after: String, $before: String, $orderBy: PaginationOrderBy) {
+      viewer {
+        assignedIssues(first: $first, after: $after, before: $before, orderBy: $orderBy) {
+          nodes { ${ISSUE_LIST_FIELDS} }
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+        }
+      }
+    }`,
+    {
+      first: limit,
+      after: params.after,
+      before: params.before,
+      orderBy: validOrderBy
+    }
+  );
+  if (data.viewer.assignedIssues.nodes.length === 0) {
+    return "No issues assigned to you.";
+  }
+  return formatConnection(data.viewer.assignedIssues, formatIssueSummary);
+}
+async function getIssueGitBranchName(client, params) {
+  const issueId = await resolveIssueId(client, params.id);
+  const data = await client.query(
+    `query($id: String!) {
+      issue(id: $id) { identifier branchName }
+    }`,
+    { id: issueId }
+  );
+  return `Branch name for ${data.issue.identifier}: ${data.issue.branchName}`;
+}
+async function resolveIssueId(client, idOrIdentifier) {
+  if (isUUID(idOrIdentifier)) return idOrIdentifier;
+  if (ISSUE_IDENTIFIER_RE2.test(idOrIdentifier)) {
+    const data = await client.query(
+      `query($term: String!, $first: Int) {
+        searchIssues(term: $term, first: $first) {
+          nodes { id identifier }
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+        }
+      }`,
+      { term: idOrIdentifier.toUpperCase(), first: 5 }
+    );
+    const match = data.searchIssues.nodes.find(
+      (n) => n.identifier.toUpperCase() === idOrIdentifier.toUpperCase()
+    );
+    if (match) return match.id;
+  }
+  throw new Error(
+    `Could not resolve issue "${idOrIdentifier}". Use a UUID or identifier like "ENG-123".`
+  );
+}
+var PROJECT_FIELDS = `
+  id name description url state progress
+  startDate targetDate createdAt updatedAt
+  lead { id name }
+  teams { nodes { id key name } }
+`;
+function formatProjectSummary(project) {
+  const lead = project.lead ? ` | Lead: ${project.lead.name}` : "";
+  const teams = project.teams.nodes.map((t) => t.key).join(", ");
+  return `${project.name} (${project.state}, ${Math.round(project.progress * 100)}%)${lead}
+  Teams: ${teams} | URL: ${project.url}
+  ID: ${project.id}`;
+}
+function formatProjectDetail(project) {
+  const lines = [
+    `# ${project.name}`,
+    "",
+    `**State:** ${project.state}`,
+    `**Progress:** ${Math.round(project.progress * 100)}%`,
+    `**Teams:** ${project.teams.nodes.map((t) => `${t.name} (${t.key})`).join(", ")}`
+  ];
+  if (project.lead) lines.push(`**Lead:** ${project.lead.name}`);
+  if (project.startDate) lines.push(`**Start Date:** ${project.startDate}`);
+  if (project.targetDate) lines.push(`**Target Date:** ${project.targetDate}`);
+  lines.push(`**URL:** ${project.url}`, `**ID:** ${project.id}`);
+  if (project.description) {
+    lines.push("", "## Description", "", project.description);
+  }
+  return lines.join("\n");
+}
+var VALID_PAGINATION_ORDER_BY3 = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+function normalizeOrderBy3(orderBy) {
+  if (!orderBy) return void 0;
+  if (VALID_PAGINATION_ORDER_BY3.has(orderBy)) return orderBy;
+  return void 0;
+}
+async function listProjects(client, params) {
+  const limit = params.limit ?? 25;
+  const validOrderBy = normalizeOrderBy3(params.orderBy);
+  if (params.teamId) {
+    const teamId = await resolveTeamId(client, params.teamId);
+    const data2 = await client.query(
+      `query($teamId: String!, $first: Int, $after: String, $before: String, $orderBy: PaginationOrderBy, $filter: ProjectFilter) {
+        team(id: $teamId) {
+          projects(first: $first, after: $after, before: $before, orderBy: $orderBy, filter: $filter) {
+            nodes { ${PROJECT_FIELDS} }
+            pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+          }
+        }
+      }`,
+      {
+        teamId,
+        first: limit,
+        after: params.after,
+        before: params.before,
+        orderBy: validOrderBy,
+        filter: buildProjectFilter(params)
+      }
+    );
+    if (data2.team.projects.nodes.length === 0) {
+      return "No projects found for this team.";
+    }
+    return formatConnection(data2.team.projects, formatProjectSummary);
+  }
+  const filter = buildProjectFilter(params);
+  const data = await client.query(
+    `query($filter: ProjectFilter, $first: Int, $after: String, $before: String, $includeArchived: Boolean, $orderBy: PaginationOrderBy) {
+      projects(filter: $filter, first: $first, after: $after, before: $before, includeArchived: $includeArchived, orderBy: $orderBy) {
+        nodes { ${PROJECT_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    {
+      filter,
+      first: limit,
+      after: params.after,
+      before: params.before,
+      includeArchived: params.includeArchived,
+      orderBy: validOrderBy
+    }
+  );
+  if (data.projects.nodes.length === 0) {
+    return "No projects found.";
+  }
+  return formatConnection(data.projects, formatProjectSummary);
+}
+function buildProjectFilter(params) {
+  const filter = {};
+  if (params.createdAt) filter.createdAt = { gte: params.createdAt };
+  if (params.updatedAt) filter.updatedAt = { gte: params.updatedAt };
+  return Object.keys(filter).length > 0 ? filter : void 0;
+}
+async function getProject(client, params) {
+  if (isUUID(params.query)) {
+    const data2 = await client.query(
+      `query($id: String!) {
+        project(id: $id) { ${PROJECT_FIELDS} }
+      }`,
+      { id: params.query }
+    );
+    return formatProjectDetail(data2.project);
+  }
+  const data = await client.query(
+    `query($name: String!) {
+      projects(filter: { name: { containsIgnoreCase: $name } }, first: 5) {
+        nodes { ${PROJECT_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { name: params.query }
+  );
+  if (data.projects.nodes.length === 0) {
+    throw new Error(`No project matching "${params.query}" found.`);
+  }
+  if (data.projects.nodes.length === 1) {
+    const first = data.projects.nodes[0];
+    if (!first) throw new Error(`No project matching "${params.query}" found.`);
+    return formatProjectDetail(first);
+  }
+  return formatConnection(data.projects, formatProjectSummary);
+}
+async function createProject(client, params) {
+  const teamId = await resolveTeamId(client, params.teamId);
+  const input = {
+    name: params.name,
+    teamIds: [teamId]
+  };
+  if (params.summary) input.summary = params.summary;
+  if (params.description) input.description = params.description;
+  if (params.startDate) input.startDate = params.startDate;
+  if (params.targetDate) input.targetDate = params.targetDate;
+  const data = await client.query(
+    `mutation($input: ProjectCreateInput!) {
+      projectCreate(input: $input) {
+        success
+        project { id name url state }
+      }
+    }`,
+    { input }
+  );
+  const project = data.projectCreate.project;
+  return `Created project: ${project.name}
+State: ${project.state}
+URL: ${project.url}
+ID: ${project.id}`;
+}
+async function updateProject(client, params) {
+  const { id, ...rest } = params;
+  const input = {};
+  for (const [key, value] of Object.entries(rest)) {
+    if (value !== void 0) {
+      input[key] = value;
+    }
+  }
+  const data = await client.query(
+    `mutation($id: String!, $input: ProjectUpdateInput!) {
+      projectUpdate(id: $id, input: $input) {
+        success
+        project { id name url state }
+      }
+    }`,
+    { id, input }
+  );
+  const project = data.projectUpdate.project;
+  return `Updated project: ${project.name}
+State: ${project.state}
+URL: ${project.url}`;
+}
+async function deleteProject(client, params) {
+  const data = await client.query(
+    `mutation($id: String!) {
+      projectDelete(id: $id) { success }
+    }`,
+    { id: params.id }
+  );
+  if (!data.projectDelete.success) {
+    throw new Error(`Failed to delete project "${params.id}".`);
+  }
+  return `Deleted project ${params.id}.`;
+}
+var TEAM_FIELDS = `
+  id name key description icon color private timezone issueCount
+`;
+function formatTeamSummary(team) {
+  const priv = team.private ? " (private)" : "";
+  return `${team.name} [${team.key}]${priv} | ${team.issueCount} issues
+  ID: ${team.id}`;
+}
+function formatTeamDetail(team) {
+  const lines = [
+    `# ${team.name} [${team.key}]`,
+    "",
+    `**ID:** ${team.id}`,
+    `**Private:** ${team.private}`,
+    `**Issues:** ${team.issueCount}`
+  ];
+  if (team.description) lines.push(`**Description:** ${team.description}`);
+  if (team.timezone) lines.push(`**Timezone:** ${team.timezone}`);
+  if (team.color) lines.push(`**Color:** ${team.color}`);
+  return lines.join("\n");
+}
+var VALID_PAGINATION_ORDER_BY4 = /* @__PURE__ */ new Set(["createdAt", "updatedAt"]);
+function normalizeOrderBy4(orderBy) {
+  if (!orderBy) return void 0;
+  if (VALID_PAGINATION_ORDER_BY4.has(orderBy)) return orderBy;
+  return void 0;
+}
+async function listTeams(client, params) {
+  const limit = params.limit ?? 50;
+  const filter = {};
+  if (params.query) filter.name = { containsIgnoreCase: params.query };
+  if (params.createdAt) filter.createdAt = { gte: params.createdAt };
+  if (params.updatedAt) filter.updatedAt = { gte: params.updatedAt };
+  const data = await client.query(
+    `query($filter: TeamFilter, $first: Int, $after: String, $before: String, $includeArchived: Boolean, $orderBy: PaginationOrderBy) {
+      teams(filter: $filter, first: $first, after: $after, before: $before, includeArchived: $includeArchived, orderBy: $orderBy) {
+        nodes { ${TEAM_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    {
+      filter: Object.keys(filter).length > 0 ? filter : void 0,
+      first: limit,
+      after: params.after,
+      before: params.before,
+      includeArchived: params.includeArchived,
+      orderBy: normalizeOrderBy4(params.orderBy)
+    }
+  );
+  if (data.teams.nodes.length === 0) {
+    return "No teams found.";
+  }
+  return formatConnection(data.teams, formatTeamSummary);
+}
+async function getTeam(client, params) {
+  if (isUUID(params.query)) {
+    const data2 = await client.query(
+      `query($id: String!) {
+        team(id: $id) { ${TEAM_FIELDS} }
+      }`,
+      { id: params.query }
+    );
+    return formatTeamDetail(data2.team);
+  }
+  const filter = {
+    or: [{ name: { containsIgnoreCase: params.query } }, { key: { eq: params.query } }]
+  };
+  const data = await client.query(
+    `query($filter: TeamFilter, $first: Int) {
+      teams(filter: $filter, first: $first) {
+        nodes { ${TEAM_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { filter, first: 5 }
+  );
+  if (data.teams.nodes.length === 0) {
+    throw new Error(`No team matching "${params.query}" found.`);
+  }
+  if (data.teams.nodes.length === 1) {
+    const first = data.teams.nodes[0];
+    if (!first) throw new Error(`No team matching "${params.query}" found.`);
+    return formatTeamDetail(first);
+  }
+  return formatConnection(data.teams, formatTeamSummary);
+}
+var USER_FIELDS = `id name displayName email active admin avatarUrl createdAt`;
+function formatUserSummary(user) {
+  const status = user.active ? "active" : "deactivated";
+  const admin = user.admin ? " (admin)" : "";
+  return `${user.displayName} <${user.email}> [${status}${admin}]
+  ID: ${user.id}`;
+}
+function formatUserDetail(user) {
+  return [
+    `# ${user.displayName}`,
+    "",
+    `**Name:** ${user.name}`,
+    `**Email:** ${user.email}`,
+    `**Active:** ${user.active}`,
+    `**Admin:** ${user.admin}`,
+    `**ID:** ${user.id}`,
+    `**Created:** ${user.createdAt}`
+  ].join("\n");
+}
+async function listUsers(client) {
+  const data = await client.query(
+    `query($first: Int) {
+      users(first: $first) {
+        nodes { ${USER_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { first: 50 }
+  );
+  if (data.users.nodes.length === 0) {
+    return "No users found.";
+  }
+  return formatConnection(data.users, formatUserSummary);
+}
+async function getUser(client, params) {
+  if (isUUID(params.query)) {
+    const data2 = await client.query(
+      `query($id: String!) {
+        user(id: $id) { ${USER_FIELDS} }
+      }`,
+      { id: params.query }
+    );
+    return formatUserDetail(data2.user);
+  }
+  const filter = {
+    or: [
+      { name: { containsIgnoreCase: params.query } },
+      { email: { containsIgnoreCase: params.query } },
+      { displayName: { containsIgnoreCase: params.query } }
+    ]
+  };
+  const data = await client.query(
+    `query($filter: UserFilter) {
+      users(filter: $filter) {
+        nodes { ${USER_FIELDS} }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { filter }
+  );
+  if (data.users.nodes.length === 0) {
+    throw new Error(`No user matching "${params.query}" found.`);
+  }
+  if (data.users.nodes.length === 1) {
+    const first = data.users.nodes[0];
+    if (!first) throw new Error(`No user matching "${params.query}" found.`);
+    return formatUserDetail(first);
+  }
+  return formatConnection(data.users, formatUserSummary);
+}
+function formatWorkflowState(state) {
+  return `[${state.type}] ${state.name} (${state.color})
+  ID: ${state.id}`;
+}
+function formatLabel(label) {
+  const parent = label.parent ? ` (parent: ${label.parent.name})` : "";
+  const desc = label.description ? ` - ${label.description}` : "";
+  return `${label.name}${parent}${desc}
+  ID: ${label.id} | Color: ${label.color}`;
+}
+async function listIssueStatuses(client, params) {
+  const teamId = await resolveTeamId(client, params.teamId);
+  const filter = { team: { id: { eq: teamId } } };
+  const data = await client.query(
+    `query($filter: WorkflowStateFilter) {
+      workflowStates(filter: $filter) {
+        nodes {
+          id name type color position description
+          team { id key name }
+        }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { filter }
+  );
+  if (data.workflowStates.nodes.length === 0) {
+    return "No workflow states found for this team.";
+  }
+  return formatConnection(data.workflowStates, formatWorkflowState);
+}
+async function getIssueStatus(client, params) {
+  if (isUUID(params.query)) {
+    const data2 = await client.query(
+      `query($id: String!) {
+        workflowState(id: $id) {
+          id name type color position description
+          team { id key name }
+        }
+      }`,
+      { id: params.query }
+    );
+    return formatWorkflowState(data2.workflowState);
+  }
+  const teamId = await resolveTeamId(client, params.teamId);
+  const filter = {
+    team: { id: { eq: teamId } },
+    name: { containsIgnoreCase: params.query }
+  };
+  const data = await client.query(
+    `query($filter: WorkflowStateFilter) {
+      workflowStates(filter: $filter) {
+        nodes {
+          id name type color position description
+          team { id key name }
+        }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { filter }
+  );
+  if (data.workflowStates.nodes.length === 0) {
+    throw new Error(`No workflow state matching "${params.query}" found in this team.`);
+  }
+  return data.workflowStates.nodes.map(formatWorkflowState).join("\n\n");
+}
+async function listIssueLabels(client, params) {
+  const teamId = await resolveTeamId(client, params.teamId);
+  const filter = { team: { id: { eq: teamId } } };
+  const data = await client.query(
+    `query($filter: IssueLabelFilter) {
+      issueLabels(filter: $filter) {
+        nodes {
+          id name color description
+          parent { id name }
+        }
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      }
+    }`,
+    { filter }
+  );
+  if (data.issueLabels.nodes.length === 0) {
+    return "No labels found for this team.";
+  }
+  return formatConnection(data.issueLabels, formatLabel);
+}
+var TOOL_DEFINITIONS = [
+  {
+    name: "list_issues",
+    description: "List issues in the user's Linear workspace. Returns issue identifiers (e.g., 'ENG-123') that can be passed directly to get_issue, update_issue, or delete_issue. Use 'query' for text search (pagination and ordering not available for text search), or structured filters with pagination. To filter by status name, first call list_issue_statuses to get the stateId. To filter by assignee name, first call list_users to get the userId, or use 'me' for the current user.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Text search query to filter issues" },
+        teamId: {
+          type: "string",
+          description: "Filter by team ID (UUID) or team key (e.g., 'ENG')"
+        },
+        stateId: {
+          type: "string",
+          description: "Filter by workflow state ID (UUID). Call list_issue_statuses to find the ID for a status name."
+        },
+        assigneeId: {
+          type: "string",
+          description: "Filter by assignee user ID. Use 'me' for current user."
+        },
+        parentId: {
+          type: "string",
+          description: "Filter by parent issue ID (for sub-issues)"
+        },
+        projectId: { type: "string", description: "Filter by project ID" },
+        createdAt: {
+          type: "string",
+          description: "Filter to issues created at or after this date (ISO 8601)"
+        },
+        updatedAt: {
+          type: "string",
+          description: "Filter to issues updated at or after this date (ISO 8601)"
+        },
+        includeArchived: {
+          type: "boolean",
+          description: "Include archived issues in results"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return (default: 25, max: 100)"
+        },
+        after: {
+          type: "string",
+          description: "Cursor for forward pagination (from previous results)"
+        },
+        orderBy: {
+          type: "string",
+          enum: ["createdAt", "updatedAt"],
+          description: "Order results by 'createdAt' or 'updatedAt'"
+        }
+      }
+    }
+  },
+  {
+    name: "get_issue",
+    description: "Retrieve a Linear issue's full details including title, description, attachments, comments (with comment UUIDs), and metadata. Accepts a UUID, an identifier like 'ENG-123', or a text search query.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Issue UUID, identifier (e.g., 'ENG-123'), or search text. Identifiers are case-insensitive."
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "create_issue",
+    description: "Create a new Linear issue or sub-issue. Before calling, use list_teams to resolve the team key and list_issue_statuses for valid stateId values.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Issue title (required)" },
+        teamId: {
+          type: "string",
+          description: "Team ID (UUID) or key (e.g., 'ENG'). Required."
+        },
+        description: {
+          type: "string",
+          description: "Issue description. Supports markdown"
+        },
+        priority: {
+          type: "number",
+          description: "Priority level: 0=No priority, 1=Urgent, 2=High, 3=Medium, 4=Low",
+          enum: [0, 1, 2, 3, 4]
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID to associate the issue with"
+        },
+        parentId: {
+          type: "string",
+          description: "Parent issue ID to create as sub-issue. teamId is still required."
+        },
+        stateId: {
+          type: "string",
+          description: "Workflow state ID (UUID) for initial status. Call list_issue_statuses to find valid IDs."
+        },
+        assigneeId: {
+          type: "string",
+          description: "User ID to assign. Use 'me' for self-assignment."
+        },
+        labelIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Array of label IDs to apply"
+        },
+        dueDate: {
+          type: "string",
+          description: "Due date in ISO 8601 format (YYYY-MM-DD)"
+        }
+      },
+      required: ["title", "teamId"]
+    }
+  },
+  {
+    name: "update_issue",
+    description: "Update an existing Linear issue. Accepts UUID or identifier (e.g., 'ENG-123'). Only provided fields are changed; omitted fields are left unchanged. Use list_issue_statuses to find stateId values.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Issue UUID or identifier (e.g., 'ENG-123')"
+        },
+        title: { type: "string", description: "New issue title" },
+        description: {
+          type: "string",
+          description: "New issue description (markdown)"
+        },
+        priority: {
+          type: "number",
+          description: "Priority: 0=None, 1=Urgent, 2=High, 3=Medium, 4=Low",
+          enum: [0, 1, 2, 3, 4]
+        },
+        projectId: {
+          type: "string",
+          description: "Project ID to move issue to"
+        },
+        parentId: {
+          type: "string",
+          description: "Parent issue ID (convert to sub-issue)"
+        },
+        stateId: {
+          type: "string",
+          description: "Workflow state ID (UUID). Call list_issue_statuses to find valid IDs."
+        },
+        assigneeId: {
+          type: "string",
+          description: "User ID to assign (use 'me' for self, null to unassign)"
+        },
+        labelIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Replacement label IDs (overwrites existing)"
+        },
+        dueDate: {
+          type: "string",
+          description: "Due date (ISO 8601 YYYY-MM-DD)"
+        },
+        estimate: {
+          type: "number",
+          description: "Complexity/effort estimate points"
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "delete_issue",
+    description: "DESTRUCTIVE: Permanently delete a Linear issue by UUID or identifier (e.g., 'ENG-123'). This cannot be undone. Always confirm with the user before deleting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Issue UUID or identifier (e.g., 'ENG-123')"
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_my_issues",
+    description: "List issues assigned to you (the authenticated user), with cursor-based pagination and ordering. Use this for browsing your issues; use list_issues for filtered searches across the workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Maximum results to return" },
+        before: {
+          type: "string",
+          description: "Cursor for backward pagination"
+        },
+        after: {
+          type: "string",
+          description: "Cursor for forward pagination"
+        },
+        orderBy: {
+          type: "string",
+          enum: ["createdAt", "updatedAt"],
+          description: "Order results by 'createdAt' or 'updatedAt'"
+        }
+      }
+    }
+  },
+  {
+    name: "get_issue_git_branch_name",
+    description: "Get the git branch name that Linear auto-generates for an issue, used to link commits and PRs back to the issue. Accepts UUID or identifier (e.g., 'ENG-123').",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Issue UUID or identifier (e.g., 'ENG-123')"
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_issue_statuses",
+    description: "List available workflow statuses for a Linear team. Returns status IDs needed for the stateId parameter in create_issue, update_issue, and list_issues filters. Accepts team UUID or key (e.g., 'ENG').",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: {
+          type: "string",
+          description: "Team ID (UUID) or key (e.g., 'ENG')"
+        }
+      },
+      required: ["teamId"]
+    }
+  },
+  {
+    name: "get_issue_status",
+    description: "Retrieve details of a specific workflow state by name or ID within a team.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Status name or ID to look up"
+        },
+        teamId: {
+          type: "string",
+          description: "Team ID the status belongs to"
+        }
+      },
+      required: ["query", "teamId"]
+    }
+  },
+  {
+    name: "list_issue_labels",
+    description: "List available issue labels for a Linear team. Returns label IDs needed for the labelIds parameter in create_issue and update_issue. Accepts team UUID or key (e.g., 'ENG').",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: {
+          type: "string",
+          description: "Team ID (UUID) or key (e.g., 'ENG')"
+        }
+      },
+      required: ["teamId"]
+    }
+  },
+  {
+    name: "list_projects",
+    description: "List projects in the user's Linear workspace. Returns project names and UUIDs. To update or delete a project, use the UUID from the output or call get_project with the project name.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Maximum results to return" },
+        before: {
+          type: "string",
+          description: "Cursor for backward pagination"
+        },
+        after: {
+          type: "string",
+          description: "Cursor for forward pagination"
+        },
+        orderBy: {
+          type: "string",
+          enum: ["createdAt", "updatedAt"],
+          description: "Order results by 'createdAt' or 'updatedAt'"
+        },
+        includeArchived: {
+          type: "boolean",
+          description: "Include archived projects"
+        },
+        teamId: {
+          type: "string",
+          description: "Filter by team ID (UUID) or team key (e.g., 'ENG')"
+        },
+        createdAt: {
+          type: "string",
+          description: "Filter by creation date"
+        },
+        updatedAt: {
+          type: "string",
+          description: "Filter by last update date"
+        }
+      }
+    }
+  },
+  {
+    name: "get_project",
+    description: "Retrieve details of a specific Linear project. Accepts a project name (fuzzy match) or UUID. Returns full details including UUID, which is needed for update_project and delete_project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Project name (fuzzy match) or UUID"
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "create_project",
+    description: "Create a new project in Linear.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Project name" },
+        teamId: {
+          type: "string",
+          description: "Team ID (UUID) or key (e.g., 'ENG')"
+        },
+        summary: {
+          type: "string",
+          description: "Short project summary (max 255 characters)"
+        },
+        description: {
+          type: "string",
+          description: "Detailed project description (markdown)"
+        },
+        startDate: {
+          type: "string",
+          description: "Project start date (ISO 8601 YYYY-MM-DD)"
+        },
+        targetDate: {
+          type: "string",
+          description: "Project target completion date (ISO 8601 YYYY-MM-DD)"
+        }
+      },
+      required: ["name", "teamId"]
+    }
+  },
+  {
+    name: "update_project",
+    description: "Update an existing Linear project by UUID. To find a project UUID, call get_project with the project name. Only provided fields are changed; omitted fields are left unchanged.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Project UUID. Call get_project with the project name to find this."
+        },
+        name: { type: "string", description: "New project name" },
+        summary: {
+          type: "string",
+          description: "Short summary (max 255 characters)"
+        },
+        description: {
+          type: "string",
+          description: "Detailed description (markdown)"
+        },
+        startDate: {
+          type: "string",
+          description: "Start date (ISO 8601 YYYY-MM-DD)"
+        },
+        targetDate: {
+          type: "string",
+          description: "Target date (ISO 8601 YYYY-MM-DD)"
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "delete_project",
+    description: "DESTRUCTIVE: Permanently delete a Linear project by UUID. This cannot be undone. Call get_project with the project name to find the UUID. Always confirm with the user before deleting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Project UUID. Call get_project with the project name to find this."
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_teams",
+    description: "List teams in the user's Linear workspace. Returns team names, keys (e.g., 'ENG'), and UUIDs. Team keys can be used as teamId in other tools.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Maximum results to return" },
+        before: {
+          type: "string",
+          description: "Cursor for backward pagination"
+        },
+        after: {
+          type: "string",
+          description: "Cursor for forward pagination"
+        },
+        orderBy: {
+          type: "string",
+          enum: ["createdAt", "updatedAt"],
+          description: "Order results by 'createdAt' or 'updatedAt'"
+        },
+        query: {
+          type: "string",
+          description: "Filter by team name or key"
+        },
+        includeArchived: {
+          type: "boolean",
+          description: "Include archived teams"
+        },
+        createdAt: {
+          type: "string",
+          description: "Filter by creation date"
+        },
+        updatedAt: {
+          type: "string",
+          description: "Filter by update date"
+        }
+      }
+    }
+  },
+  {
+    name: "get_team",
+    description: "Retrieve details of a specific Linear team by name, key, or ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Team name, key, or ID to look up"
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "list_users",
+    description: "List users in the Linear workspace with their UUIDs, names, emails, and active status. Returns up to 50 users. User UUIDs can be used as assigneeId in other tools.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "get_user",
+    description: "Retrieve details of a specific Linear user by name, email, or ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "User name, email, or ID to look up"
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "list_comments",
+    description: "Retrieve comments on a Linear issue. Returns comment text, authors, and comment UUIDs. Accepts an issue UUID or identifier (e.g., 'ENG-123'). To delete a specific comment, use the comment UUID from the output with delete_comment.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        issueId: {
+          type: "string",
+          description: "Issue UUID or identifier (e.g., 'ENG-123')"
+        }
+      },
+      required: ["issueId"]
+    }
+  },
+  {
+    name: "create_comment",
+    description: "Create a new comment on a Linear issue. Accepts issue UUID or identifier (e.g., 'ENG-123').",
+    inputSchema: {
+      type: "object",
+      properties: {
+        issueId: {
+          type: "string",
+          description: "Issue UUID or identifier (e.g., 'ENG-123')"
+        },
+        body: {
+          type: "string",
+          description: "Comment body text. Supports markdown formatting"
+        }
+      },
+      required: ["issueId", "body"]
+    }
+  },
+  {
+    name: "delete_comment",
+    description: "DESTRUCTIVE: Permanently delete a Linear issue comment by UUID. This cannot be undone. Comment UUIDs are returned by list_comments and get_issue. Always confirm with the user before deleting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Comment UUID. Find this via list_comments or get_issue."
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "get_document",
+    description: "Retrieve a Linear document by ID or slug.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Document ID (UUID) or slug"
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "list_documents",
+    description: "List documents in the user's Linear workspace. Supports filtering by project, creator, title search, and date ranges.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Maximum results to return" },
+        before: {
+          type: "string",
+          description: "Cursor for backward pagination"
+        },
+        after: {
+          type: "string",
+          description: "Cursor for forward pagination"
+        },
+        orderBy: {
+          type: "string",
+          enum: ["createdAt", "updatedAt"],
+          description: "Order results by 'createdAt' or 'updatedAt'"
+        },
+        query: { type: "string", description: "Text search query" },
+        projectId: { type: "string", description: "Filter by project ID" },
+        creatorId: {
+          type: "string",
+          description: "Filter by creator user ID"
+        },
+        createdAt: {
+          type: "string",
+          description: "Filter by creation date"
+        },
+        updatedAt: {
+          type: "string",
+          description: "Filter by update date"
+        },
+        includeArchived: {
+          type: "boolean",
+          description: "Include archived documents"
+        }
+      }
+    }
+  },
+  {
+    name: "search_documentation",
+    description: "Search Linear's own documentation to learn about Linear features and usage. This is NOT for searching user workspace data -- it searches Linear's help docs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query for Linear documentation"
+        },
+        page: {
+          type: "number",
+          description: "Page number for paginated results"
+        }
+      },
+      required: ["query"]
+    }
+  }
+];
+function getClient() {
+  const token = process.env.LINEAR_ACCESS_TOKEN;
+  if (!token) {
+    throw new Error(
+      "LINEAR_ACCESS_TOKEN environment variable is required. Set it to a Linear API key or OAuth access token."
+    );
+  }
+  return new LinearGraphQLClient(token);
+}
+async function handleToolCall(name, args) {
+  const client = getClient();
+  const a = args;
+  switch (name) {
+    case "list_issues":
+      return listIssues(client, a);
+    case "get_issue":
+      return getIssue(client, a);
+    case "create_issue":
+      return createIssue(client, a);
+    case "update_issue":
+      return updateIssue(client, a);
+    case "delete_issue":
+      return deleteIssue(client, a);
+    case "list_my_issues":
+      return listMyIssues(client, a);
+    case "get_issue_git_branch_name":
+      return getIssueGitBranchName(client, a);
+    case "list_issue_statuses":
+      return listIssueStatuses(client, a);
+    case "get_issue_status":
+      return getIssueStatus(client, a);
+    case "list_issue_labels":
+      return listIssueLabels(client, a);
+    case "list_projects":
+      return listProjects(client, a);
+    case "get_project":
+      return getProject(client, a);
+    case "create_project":
+      return createProject(client, a);
+    case "update_project":
+      return updateProject(client, a);
+    case "delete_project":
+      return deleteProject(client, a);
+    case "list_teams":
+      return listTeams(client, a);
+    case "get_team":
+      return getTeam(client, a);
+    case "list_users":
+      return listUsers(client);
+    case "get_user":
+      return getUser(client, a);
+    case "list_comments":
+      return listComments(client, a);
+    case "create_comment":
+      return createComment(client, a);
+    case "delete_comment":
+      return deleteComment(client, a);
+    case "get_document":
+      return getDocument(client, a);
+    case "list_documents":
+      return listDocuments(client, a);
+    case "search_documentation":
+      return searchDocumentation(client, a);
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+async function main() {
+  const server = new Server(
+    { name: "@shipyard/linear-mcp", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [...TOOL_DEFINITIONS]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      const result = await handleToolCall(name, args ?? {});
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { content: [{ type: "text", text: message }], isError: true };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main();
+//# sourceMappingURL=plugin-mcp-linear.js.map