DevOps Enhanced MCP

Instructions

Implementation Reference

• src/handlers/tool-handlers.ts:996-1062 (handler)

  The primary handler function that implements the 'get-pull-requests' tool logic. It constructs the Azure DevOps Git API endpoint with filters for status, creator, repository, and limit, fetches the data using makeApiRequest, processes the pull requests into a formatted response, and returns it in MCP format.

  private async getPullRequests(args: any): Promise<any> {
    try {
      let endpoint = '/git/pullrequests?api-version=7.1';
      
      const params = [];
      
      // Status filter (default to active)
      const status = args.status || 'active';
      if (status !== 'all') {
        params.push(`searchCriteria.status=${status}`);
      }
      
      // Creator filter
      if (args.createdBy) {
        params.push(`searchCriteria.creatorId=${encodeURIComponent(args.createdBy)}`);
      }
      
      // Repository filter
      if (args.repositoryId) {
        params.push(`searchCriteria.repositoryId=${encodeURIComponent(args.repositoryId)}`);
      }
      
      // Top (limit) parameter
      const top = args.top || 25;
      params.push(`$top=${top}`);
      
      if (params.length > 0) {
        endpoint += '&' + params.join('&');
      }
  
      const result = await this.makeApiRequest(endpoint);
  
      const pullRequests = result.value.map((pr: any) => ({
        id: pr.pullRequestId,
        title: pr.title,
        description: pr.description,
        status: pr.status,
        createdBy: {
          displayName: pr.createdBy.displayName,
          uniqueName: pr.createdBy.uniqueName
        },
        creationDate: pr.creationDate,
        repository: {
          id: pr.repository.id,
          name: pr.repository.name
        },
        sourceRefName: pr.sourceRefName,
        targetRefName: pr.targetRefName,
        url: pr._links?.web?.href || `${this.currentConfig!.organizationUrl}/${this.currentConfig!.project}/_git/${pr.repository.name}/pullrequest/${pr.pullRequestId}`,
        isDraft: pr.isDraft || false,
        mergeStatus: pr.mergeStatus
      }));
  
      return {
        content: [{
          type: 'text',
          text: JSON.stringify({
            count: pullRequests.length,
            status: status,
            pullRequests
          }, null, 2),
        }],
      };
    } catch (error) {
      throw new Error(`Failed to get pull requests: ${error instanceof Error ? error.message : 'Unknown error'}`);
    }
  }

• src/index.ts:261-285 (registration)

  The tool registration in the listTools handler, including the name 'get-pull-requests', description, and input schema definition for MCP tool discovery.

    name: 'get-pull-requests',
    description: 'Get pull requests from Azure DevOps repository',
    inputSchema: {
      type: 'object',
      properties: {
        repositoryId: {
          type: 'string',
          description: 'Repository ID or name (optional, defaults to all repos)',
        },
        status: {
          type: 'string',
          enum: ['active', 'completed', 'abandoned', 'all'],
          description: 'Pull request status filter (default: active)',
        },
        createdBy: {
          type: 'string',
          description: 'Filter by creator (user ID or email)',
        },
        top: {
          type: 'number',
          description: 'Number of pull requests to return (default: 25)',
        },
      },
    },
  },

• src/handlers/tool-handlers.ts:45-46 (handler)

  The switch case dispatcher in handleToolCall that routes 'get-pull-requests' calls to the getPullRequests implementation.

  case 'get-pull-requests':
    return await this.getPullRequests(args || {});

• src/index.ts:263-285 (schema)

  The input schema definition for the 'get-pull-requests' tool, specifying parameters like repositoryId, status, createdBy, and top.

    inputSchema: {
      type: 'object',
      properties: {
        repositoryId: {
          type: 'string',
          description: 'Repository ID or name (optional, defaults to all repos)',
        },
        status: {
          type: 'string',
          enum: ['active', 'completed', 'abandoned', 'all'],
          description: 'Pull request status filter (default: active)',
        },
        createdBy: {
          type: 'string',
          description: 'Filter by creator (user ID or email)',
        },
        top: {
          type: 'number',
          description: 'Number of pull requests to return (default: 25)',
        },
      },
    },
  },

• src/handlers/tool-handlers.ts:71-131 (helper)

  The makeApiRequest helper method used by getPullRequests to make authenticated HTTPS requests to the Azure DevOps REST API.

  private async makeApiRequest(endpoint: string, method: string = 'GET', body?: any): Promise<any> {
    if (!this.currentConfig) {
      throw new Error('No configuration available');
    }
  
    const { organizationUrl, pat, project } = this.currentConfig;
    const baseUrl = `${organizationUrl}/${project}/_apis`;
    const requestUrl = `${baseUrl}${endpoint}`;
    
    return new Promise((resolve, reject) => {
      const urlParts = new url.URL(requestUrl);
      const postData = body ? JSON.stringify(body) : undefined;
      
      const options = {
        hostname: urlParts.hostname,
        port: urlParts.port || 443,
        path: urlParts.pathname + urlParts.search,
        method,
        headers: {
          'Authorization': `Basic ${Buffer.from(`:${pat}`).toString('base64')}`,
          'Content-Type': method === 'PATCH' && endpoint.includes('/wit/workitems/')
            ? 'application/json-patch+json'
            : 'application/json',
          'Accept': 'application/json',
          // For preview APIs, we need to properly handle the API version in the URL, not headers
          ...(postData && { 'Content-Length': Buffer.byteLength(postData) }),
        },
      };
  
      const req = https.request(options, (res) => {
        let data = '';
        
        res.on('data', (chunk) => {
          data += chunk;
        });
        
        res.on('end', () => {
          try {
            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
              const result = data ? JSON.parse(data) : {};
              resolve(result);
            } else {
              reject(new Error(`HTTP ${res.statusCode}: ${data}`));
            }
          } catch (error) {
            reject(new Error(`Failed to parse response: ${error}`));
          }
        });
      });
  
      req.on('error', (error) => {
        reject(new Error(`Request failed: ${error.message}`));
      });
  
      if (postData) {
        req.write(postData);
      }
      
      req.end();
    });
  }