Linear

Instructions

Implementation Reference

• src/tools/handlers/issue-handlers.ts:85-98 (handler)

  The core handler function for the linear_createIssue tool. It validates the input arguments using isCreateIssueArgs type guard and delegates the creation to LinearService.createIssue.

  export function handleCreateIssue(linearService: LinearService) {
    return async (args: unknown) => {
      try {
        if (!isCreateIssueArgs(args)) {
          throw new Error('Invalid arguments for createIssue');
        }
  
        return await linearService.createIssue(args);
      } catch (error) {
        logError('Error creating issue', error);
        throw error;
      }
    };
  }

• src/tools/definitions/issue-tools.ts:186-267 (schema)

  The tool definition (schema) for linear_createIssue, specifying input parameters (e.g., title, teamId required) and output structure.

  export const createIssueToolDefinition: MCPToolDefinition = {
    name: 'linear_createIssue',
    description: 'Create a new issue in Linear',
    input_schema: {
      type: 'object',
      properties: {
        title: {
          type: 'string',
          description: 'Title of the issue',
        },
        description: {
          type: 'string',
          description: 'Description of the issue (Markdown supported)',
        },
        teamId: {
          type: 'string',
          description: 'ID of the team the issue belongs to',
        },
        assigneeId: {
          type: 'string',
          description: 'ID of the user to assign the issue to',
        },
        priority: {
          type: 'number',
          description:
            'Priority of the issue (0 = No priority, 1 = Urgent, 2 = High, 3 = Normal, 4 = Low)',
        },
        projectId: {
          type: 'string',
          description: 'ID of the project the issue belongs to',
        },
        cycleId: {
          type: 'string',
          description: 'ID of the cycle to add the issue to',
        },
        estimate: {
          type: 'number',
          description: 'The estimated complexity/points for the issue',
        },
        dueDate: {
          type: 'string',
          description: 'The date at which the issue is due (YYYY-MM-DD format)',
        },
        labelIds: {
          type: 'array',
          items: { type: 'string' },
          description: 'IDs of the labels to attach to the issue',
        },
        parentId: {
          type: 'string',
          description: 'ID of the parent issue (to create as a sub-task)',
        },
        subscriberIds: {
          type: 'array',
          items: { type: 'string' },
          description: 'IDs of the users to subscribe to the issue',
        },
        stateId: {
          type: 'string',
          description: 'ID of the workflow state for the issue',
        },
        templateId: {
          type: 'string',
          description: 'ID of a template to use for creating the issue',
        },
        sortOrder: {
          type: 'number',
          description: 'The position of the issue in relation to other issues',
        },
      },
      required: ['title', 'teamId'],
    },
    output_schema: {
      type: 'object',
      properties: {
        id: { type: 'string' },
        identifier: { type: 'string' },
        title: { type: 'string' },
        url: { type: 'string' },
      },
    },
  };

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

  Registration of the linear_createIssue handler within the registerToolHandlers function, mapping the tool name to the wrapped handleCreateIssue function.

  linear_createIssue: handleCreateIssue(linearService),

• src/tools/type-guards.ts:92-132 (helper)

  Type guard function isCreateIssueArgs used by the handler to validate input arguments before calling the Linear service.

   * Type guard for linear_createIssue tool arguments
   */
  export function isCreateIssueArgs(args: unknown): args is {
    title: string;
    description?: string;
    teamId: string;
    assigneeId?: string;
    priority?: number;
    projectId?: string;
    cycleId?: string;
    estimate?: number;
    dueDate?: string;
    labelIds?: string[];
    parentId?: string;
    subscriberIds?: string[];
    stateId?: string;
    templateId?: string;
    sortOrder?: number;
  } {
    return (
      typeof args === 'object' &&
      args !== null &&
      'title' in args &&
      typeof (args as { title: string }).title === 'string' &&
      'teamId' in args &&
      typeof (args as { teamId: string }).teamId === 'string' &&
      (!('assigneeId' in args) || typeof (args as { assigneeId: string }).assigneeId === 'string') &&
      (!('priority' in args) || typeof (args as { priority: number }).priority === 'number') &&
      (!('projectId' in args) || typeof (args as { projectId: string }).projectId === 'string') &&
      (!('cycleId' in args) || typeof (args as { cycleId: string }).cycleId === 'string') &&
      (!('estimate' in args) || typeof (args as { estimate: number }).estimate === 'number') &&
      (!('dueDate' in args) || typeof (args as { dueDate: string }).dueDate === 'string') &&
      (!('labelIds' in args) || Array.isArray((args as { labelIds: string[] }).labelIds)) &&
      (!('parentId' in args) || typeof (args as { parentId: string }).parentId === 'string') &&
      (!('subscriberIds' in args) ||
        Array.isArray((args as { subscriberIds: string[] }).subscriberIds)) &&
      (!('stateId' in args) || typeof (args as { stateId: string }).stateId === 'string') &&
      (!('templateId' in args) || typeof (args as { templateId: string }).templateId === 'string') &&
      (!('sortOrder' in args) || typeof (args as { sortOrder: number }).sortOrder === 'number')
    );
  }