filter_results

Instructions

Implementation Reference

• src/index.ts:549-603 (handler)

  The handler function `handleFilterResults` that executes the filter_results tool logic. It reads a JSON results file, parses it, and applies optional filters: severity, rule_id, path_pattern (regex), language, and message_pattern (regex). Returns filtered results as JSON.

  private async handleFilterResults(args: any) {
    if (!args.results_file) {
      throw new McpError(ErrorCode.InvalidParams, 'results_file is required');
    }
  
    const resultsFile = validateAbsolutePath(args.results_file, 'results_file');
  
    try {
      const fileContent = await readFile(resultsFile, 'utf-8');
      const results = parseSemgrepResults(fileContent);
  
      let filteredResults = getSemgrepFindings(results);
  
      if (args.severity) {
        filteredResults = filteredResults.filter(
          (finding: any) => finding.extra?.severity === args.severity
        );
      }
  
      if (args.rule_id) {
        filteredResults = filteredResults.filter(
          (finding: any) => finding.check_id === args.rule_id
        );
      }
  
      if (args.path_pattern) {
        const pathRegex = new RegExp(args.path_pattern);
        filteredResults = filteredResults.filter(
          (finding: any) => pathRegex.test(finding.path)
        );
      }
  
      if (args.language) {
        filteredResults = filteredResults.filter(
          (finding: any) => finding.extra?.metadata?.language === args.language
        );
      }
  
      if (args.message_pattern) {
        const messageRegex = new RegExp(args.message_pattern);
        filteredResults = filteredResults.filter(
          (finding: any) => messageRegex.test(finding.extra?.message ?? '')
        );
      }
  
      return {
        content: [{ type: 'text', text: JSON.stringify({ results: filteredResults }, null, 2) }]
      };
    } catch (error: any) {
      return {
        content: [{ type: 'text', text: `Error filtering results: ${error.message}` }],
        isError: true
      };
    }
  }

• src/index.ts:323-337 (schema)

  The input schema definition for the filter_results tool. Defines properties: results_file (required), severity, rule_id, path_pattern, language, message_pattern.

  {
    name: 'filter_results',
    description: 'Filters scan results by various criteria',
    inputSchema: {
      type: 'object',
      properties: {
        results_file: { type: 'string', description: 'Absolute path to JSON results file' },
        severity: { type: 'string', description: 'Filter by severity (ERROR, WARNING, INFO)' },
        rule_id: { type: 'string', description: 'Filter by rule ID' },
        path_pattern: { type: 'string', description: 'Filter by file path pattern (regex)' },
        language: { type: 'string', description: 'Filter by programming language' },
        message_pattern: { type: 'string', description: 'Filter by message content (regex)' }
      },
      required: ['results_file']
    }

• src/index.ts:371-395 (registration)

  The CallToolRequestSchema handler that routes 'filter_results' tool calls to handleFilterResults.

  this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
    await this.ensureSemgrepAvailable();
  
    switch (request.params.name) {
    case 'scan_directory':
      return await this.handleScanDirectory(request.params.arguments);
    case 'list_rules':
      return await this.handleListRules(request.params.arguments);
    case 'analyze_results':
      return await this.handleAnalyzeResults(request.params.arguments);
    case 'create_rule':
      return await this.handleCreateRule(request.params.arguments);
    case 'filter_results':
      return await this.handleFilterResults(request.params.arguments);
    case 'export_results':
      return await this.handleExportResults(request.params.arguments);
    case 'compare_results':
      return await this.handleCompareResults(request.params.arguments);
    default:
      throw new McpError(
        ErrorCode.MethodNotFound,
        `Unknown tool: ${request.params.name}`
      );
    }
  });

• src/index.ts:102-103 (helper)

  Helper function `getSemgrepFindings` used by handleFilterResults to extract the results array from parsed Semgrep output.

  function getSemgrepFindings(results: SemgrepResults): SemgrepFinding[] {
    return Array.isArray(results.results) ? results.results : [];

• src/index.ts:92-100 (helper)

  Helper function `parseSemgrepResults` used by handleFilterResults to parse JSON file content into a SemgrepResults object.

  export function parseSemgrepResults(fileContent: string): SemgrepResults {
    const parsedContent = JSON.parse(fileContent);
  
    if (!parsedContent || typeof parsedContent !== 'object' || Array.isArray(parsedContent)) {
      return {};
    }
  
    return parsedContent as SemgrepResults;
  }