Linear

Instructions

Implementation Reference

• src/tools/handlers/issue-handlers.ts:265-278 (handler)

  The main handler function for the linear_setIssuePriority tool. It validates the input arguments using a type guard and delegates the actual priority update to the LinearService.

  export function handleSetIssuePriority(linearService: LinearService) {
    return async (args: unknown) => {
      try {
        if (!isSetIssuePriorityArgs(args)) {
          throw new Error('Invalid arguments for setIssuePriority');
        }
  
        return await linearService.setIssuePriority(args.issueId, args.priority);
      } catch (error) {
        logError('Error setting issue priority', error);
        throw error;
      }
    };
  }

• src/tools/definitions/issue-tools.ts:632-666 (schema)

  The tool schema definition including input and output schemas for linear_setIssuePriority.

  export const setIssuePriorityToolDefinition: MCPToolDefinition = {
    name: 'linear_setIssuePriority',
    description: 'Set the priority of an issue',
    input_schema: {
      type: 'object',
      properties: {
        issueId: {
          type: 'string',
          description: 'ID or identifier of the issue (e.g., ABC-123)',
        },
        priority: {
          type: 'number',
          description: 'Priority level (0 = No priority, 1 = Urgent, 2 = High, 3 = Normal, 4 = Low)',
          enum: [0, 1, 2, 3, 4],
        },
      },
      required: ['issueId', 'priority'],
    },
    output_schema: {
      type: 'object',
      properties: {
        success: { type: 'boolean' },
        issue: {
          type: 'object',
          properties: {
            id: { type: 'string' },
            identifier: { type: 'string' },
            title: { type: 'string' },
            priority: { type: 'number' },
            url: { type: 'string' },
          },
        },
      },
    },
  };

• src/tools/handlers/index.ts:118-118 (registration)

  Registration of the tool handler in the registerToolHandlers function.

  linear_setIssuePriority: handleSetIssuePriority(linearService),

• src/tools/type-guards.ts:343-358 (schema)

  Type guard function for validating the input arguments of linear_setIssuePriority.

   * Type guard for linear_setIssuePriority tool arguments
   */
  export function isSetIssuePriorityArgs(args: unknown): args is {
    issueId: string;
    priority: number;
  } {
    return (
      typeof args === 'object' &&
      args !== null &&
      'issueId' in args &&
      typeof (args as { issueId: string }).issueId === 'string' &&
      'priority' in args &&
      typeof (args as { priority: number }).priority === 'number' &&
      [0, 1, 2, 3, 4].includes((args as { priority: number }).priority)
    );
  }

• src/services/linear-service.ts:863-893 (helper)

  The LinearService method that performs the actual API call to update the issue priority using the Linear SDK.

  async setIssuePriority(issueId: string, priority: number) {
    try {
      // Get the issue
      const issue = await this.client.issue(issueId);
      if (!issue) {
        throw new Error(`Issue with ID ${issueId} not found`);
      }
  
      // Update the issue priority
      await issue.update({
        priority: priority,
      });
  
      // Get the updated issue
      const updatedIssue = await this.client.issue(issue.id);
  
      return {
        success: true,
        issue: {
          id: updatedIssue.id,
          identifier: updatedIssue.identifier,
          title: updatedIssue.title,
          priority: updatedIssue.priority,
          url: updatedIssue.url,
        },
      };
    } catch (error) {
      console.error('Error setting issue priority:', error);
      throw error;
    }
  }