Linear

Instructions

Implementation Reference

• src/tools/handlers/issue-handlers.ts:226-242 (handler)

  The MCP tool handler that validates input using type guard and calls LinearService.createIssueRelation to execute the tool logic

  /**
   * Handler for creating an issue relation
   */
  export function handleCreateIssueRelation(linearService: LinearService) {
    return async (args: unknown) => {
      try {
        if (!isCreateIssueRelationArgs(args)) {
          throw new Error('Invalid arguments for createIssueRelation');
        }
  
        return await linearService.createIssueRelation(args.issueId, args.relatedIssueId, args.type);
      } catch (error) {
        logError('Error creating issue relation', error);
        throw error;
      }
    };
  }

• src/services/linear-service.ts:794-834 (helper)

  The service method implementing the core logic: fetches issues, validates relation type, calls Linear SDK's createIssueRelation

   * Creates a relation between two issues
   */
  async createIssueRelation(issueId: string, relatedIssueId: string, relationType: string) {
    try {
      // Get both issues
      const issue = await this.client.issue(issueId);
      if (!issue) {
        throw new Error(`Issue with ID ${issueId} not found`);
      }
  
      const relatedIssue = await this.client.issue(relatedIssueId);
      if (!relatedIssue) {
        throw new Error(`Related issue with ID ${relatedIssueId} not found`);
      }
  
      const validTypes = ["blocks", "duplicate", "related"];
      
      if (!validTypes.includes(relationType)) {
        throw new Error(`${relationType} is not a valid relation type`)
      }
  
      const relation = await this.client.createIssueRelation({
        issueId,
        relatedIssueId,
        // @ts-ignore
        type: relationType, 
      })
  
      // For now, we'll just acknowledge the request with a success message
      // The actual relation creation logic would need to be implemented based on the Linear SDK specifics
      // In a production environment, we should check the SDK documentation for the correct method
  
      return {
        success: true,
        relation,
      };
    } catch (error) {
      console.error('Error creating issue relation:', error);
      throw error;
    }
  }

• src/tools/definitions/issue-tools.ts:564-602 (schema)

  MCPToolDefinition providing input/output schemas, description, and parameters for the tool

  export const createIssueRelationToolDefinition: MCPToolDefinition = {
    name: 'linear_createIssueRelation',
    description: 'Create relations between issues (blocks, is blocked by, etc.)',
    input_schema: {
      type: 'object',
      properties: {
        issueId: {
          type: 'string',
          description: 'ID or identifier of the first issue (e.g., ABC-123)',
        },
        relatedIssueId: {
          type: 'string',
          description: 'ID or identifier of the second issue (e.g., ABC-456)',
        },
        type: {
          type: 'string',
          description:
            "Type of relation: 'blocks', 'blocked_by', 'related', 'duplicate', 'duplicate_of'",
          enum: ['blocks', 'blocked_by', 'related', 'duplicate', 'duplicate_of'],
        },
      },
      required: ['issueId', 'relatedIssueId', 'type'],
    },
    output_schema: {
      type: 'object',
      properties: {
        success: { type: 'boolean' },
        relation: {
          type: 'object',
          properties: {
            id: { type: 'string' },
            type: { type: 'string' },
            issueIdentifier: { type: 'string' },
            relatedIssueIdentifier: { type: 'string' },
          },
        },
      },
    },
  };

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

  Tool registration in the handlers map returned by registerToolHandlers

  linear_createIssueRelation: handleCreateIssueRelation(linearService),

• src/tools/type-guards.ts:306-326 (helper)

  Type guard function used by the handler to validate tool input arguments

   * Type guard for linear_createIssueRelation tool arguments
   */
  export function isCreateIssueRelationArgs(args: unknown): args is {
    issueId: string;
    relatedIssueId: string;
    type: 'blocks' | 'blocked_by' | 'related' | 'duplicate' | 'duplicate_of';
  } {
    return (
      typeof args === 'object' &&
      args !== null &&
      'issueId' in args &&
      typeof (args as { issueId: string }).issueId === 'string' &&
      'relatedIssueId' in args &&
      typeof (args as { relatedIssueId: string }).relatedIssueId === 'string' &&
      'type' in args &&
      typeof (args as { type: string }).type === 'string' &&
      ['blocks', 'blocked_by', 'related', 'duplicate', 'duplicate_of'].includes(
        (args as { type: string }).type,
      )
    );
  }