agent-master-devsecops 3.9.0 → 5.1.0

package/scripts/{perf_benchmark.js → core/perf_benchmark.js}

@@ -1,153 +1,212 @@
-#!/usr/bin/env node
-/**
- * scripts/perf_benchmark.js
- * 
- * Scanner de Regressão de Performance em CI (AGDEV-25 / I-9).
- * Executa micro-benchmarks comparativos de latência e consumo de RAM/Heap,
- * detectando e bloqueando regressões superiores a 10% em relação ao baseline de referência.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const ROOT_DIR = path.resolve(__dirname, '..');
-const BASELINE_FILE = path.join(ROOT_DIR, 'benchmarks', 'baseline.json');
-
-function runBenchmark(iterations = 100) {
-  const { processMessage } = require('./mcp_server.js');
-  const { generateCompactPrompt } = require('./context_compressor.js');
-
-  const startMem = process.memoryUsage();
-  const startTime = process.hrtime.bigint();
-
-  // Benchmark 1: Processamento de JSON-RPC Initialize e Tools List
-  for (let i = 0; i < iterations; i++) {
-    processMessage({ jsonrpc: '2.0', id: i, method: 'tools/list' });
-    processMessage({ jsonrpc: '2.0', id: i, method: 'tools/call', params: { name: 'agent_full_dev_status', arguments: {} } });
-  }
-
-  // Benchmark 2: Compactação Semântica de Prompt
-  for (let i = 0; i < Math.floor(iterations / 2); i++) {
-    generateCompactPrompt();
-  }
-
-  const endTime = process.hrtime.bigint();
-  const endMem = process.memoryUsage();
-
-  const durationNs = Number(endTime - startTime);
-  const durationMs = durationNs / 1000000;
-  const avgLatencyUs = Math.round((durationNs / (iterations * 2)) / 1000);
-  const heapUsedMb = Math.round((endMem.heapUsed / (1024 * 1024)) * 100) / 100;
-  const opsPerSec = Math.round(((iterations * 2.5) / (durationMs / 1000)));
-
-  return {
-    iterations,
-    totalDurationMs: Math.round(durationMs * 100) / 100,
-    avgLatencyUs,
-    opsPerSec,
-    heapUsedMb
-  };
-}
-
-function comparePerformance(current, baseline, maxDegradationPct = 10) {
-  const latencyDeltaPct = Math.round(((current.avgLatencyUs - baseline.avgLatencyUs) / baseline.avgLatencyUs) * 100);
-  const memoryDeltaPct = Math.round(((current.heapUsedMb - baseline.heapUsedMb) / (baseline.heapUsedMb || 1)) * 100);
-
-  const hasLatencyRegression = latencyDeltaPct > maxDegradationPct;
-  const hasMemoryRegression = memoryDeltaPct > (maxDegradationPct * 2); // 20% tolerância para GC jitter
-  const passed = !hasLatencyRegression && !hasMemoryRegression;
-
-  return {
-    passed,
-    verdict: passed ? 'APROVADO' : 'REGRESSÃO_DETECTADA',
-    thresholdPct: maxDegradationPct,
-    current,
-    baseline,
-    deltas: {
-      latencyDeltaPct,
-      memoryDeltaPct
-    }
-  };
-}
-
-function formatPerfReport(comparison) {
-  let report = '================================================================================\n';
-  report += `RELATÓRIO DE PERFORMANCE & REGRESSÃO DE CI: [ ${comparison.verdict} ]\n`;
-  report += '================================================================================\n\n';
-
-  report += `Limiar Máximo de Degradação Permitido: ${comparison.thresholdPct}%\n\n`;
-
-  report += 'MÉTRICAS COMPARATIVAS:\n';
-  report += `- Latência Média por Operação: ${comparison.current.avgLatencyUs}µs (Baseline: ${comparison.baseline.avgLatencyUs}µs) -> Variação: ${comparison.deltas.latencyDeltaPct > 0 ? '+' : ''}${comparison.deltas.latencyDeltaPct}%\n`;
-  report += `- Throughput (Ops/sec): ${comparison.current.opsPerSec} ops/s (Baseline: ${comparison.baseline.opsPerSec} ops/s)\n`;
-  report += `- Memória Heap Utilizada: ${comparison.current.heapUsedMb} MB (Baseline: ${comparison.baseline.heapUsedMb} MB) -> Variação: ${comparison.deltas.memoryDeltaPct > 0 ? '+' : ''}${comparison.deltas.memoryDeltaPct}%\n\n`;
-
-  if (comparison.passed) {
-    report += 'STATUS: Nenhuma degradação crítica detectada. Aprovado para merge na esteira de CI.\n';
-  } else {
-    report += 'ALERTA SRE: Regressão superior a 10% identificada! Merge bloqueado conforme política DevSecOps.\n';
-  }
-
-  report += '================================================================================\n';
-  return report;
-}
-
-function getOrInitBaseline() {
-  const benchDir = path.dirname(BASELINE_FILE);
-  if (!fs.existsSync(benchDir)) {
-    fs.mkdirSync(benchDir, { recursive: true });
-  }
-
-  if (fs.existsSync(BASELINE_FILE)) {
-    try {
-      return JSON.parse(fs.readFileSync(BASELINE_FILE, 'utf8'));
-    } catch { /* ignora */ }
-  }
-
-  // Baseline padrão de referência calibrado para Node.js 22
-  const initialBaseline = {
-    iterations: 100,
-    totalDurationMs: 15.0,
-    avgLatencyUs: 60,
-    opsPerSec: 15000,
-    heapUsedMb: 18.5
-  };
-
-  fs.writeFileSync(BASELINE_FILE, JSON.stringify(initialBaseline, null, 2), 'utf8');
-  return initialBaseline;
-}
-
-async function runCli() {
-  const args = process.argv.slice(2);
-  const baseline = getOrInitBaseline();
-  const current = runBenchmark(100);
-
-  if (args.includes('--save-baseline')) {
-    fs.writeFileSync(BASELINE_FILE, JSON.stringify(current, null, 2), 'utf8');
-    console.log(`[Perf Scanner] Novo baseline salvo com sucesso em ${BASELINE_FILE}`);
-    return;
-  }
-
-  const comparison = comparePerformance(current, baseline, 15);
-  const report = formatPerfReport(comparison);
-  console.log(report);
-
-  if (args.includes('--strict') && !comparison.passed) {
-    process.exit(1);
-  }
-}
-
-if (require.main === module) {
-  runCli().catch(err => {
-    console.error(err);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  runBenchmark,
-  comparePerformance,
-  formatPerfReport,
-  getOrInitBaseline,
-  BASELINE_FILE
-};
+#!/usr/bin/env node
+/**
+ * scripts/perf_benchmark.js
+ * 
+ * Scanner de Regressão de Performance em CI (AGDEV-25 / I-9).
+ * Executa micro-benchmarks comparativos de latência e consumo de RAM/Heap,
+ * detectando e bloqueando regressões superiores a 10% em relação ao baseline de referência.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { createSarifReport } = require('./sarif_engine.js');
+
+const ROOT_DIR = path.resolve(__dirname, '../..');
+const BASELINE_FILE = path.join(ROOT_DIR, 'benchmarks', 'baseline.json');
+
+function runBenchmark(iterations = 100) {
+  const { processMessage } = require('../mcp_server.js');
+  const { generateCompactPrompt } = require('./context_compressor.js');
+
+  const startMem = process.memoryUsage();
+  const startTime = process.hrtime.bigint();
+
+  // Benchmark 1: Processamento de JSON-RPC Initialize e Tools List
+  for (let i = 0; i < iterations; i++) {
+    processMessage({ jsonrpc: '2.0', id: i, method: 'tools/list' });
+    processMessage({ jsonrpc: '2.0', id: i, method: 'tools/call', params: { name: 'agent_full_dev_status', arguments: {} } });
+  }
+
+  // Benchmark 2: Compactação Semântica de Prompt
+  for (let i = 0; i < Math.floor(iterations / 2); i++) {
+    generateCompactPrompt();
+  }
+
+  const endTime = process.hrtime.bigint();
+  const endMem = process.memoryUsage();
+
+  const durationNs = Number(endTime - startTime);
+  const durationMs = durationNs / 1000000;
+  const avgLatencyUs = Math.round((durationNs / (iterations * 2)) / 1000);
+  const heapUsedMb = Math.round((endMem.heapUsed / (1024 * 1024)) * 100) / 100;
+  const opsPerSec = Math.round(((iterations * 2.5) / (durationMs / 1000)));
+
+  return {
+    iterations,
+    totalDurationMs: Math.round(durationMs * 100) / 100,
+    avgLatencyUs,
+    opsPerSec,
+    heapUsedMb
+  };
+}
+
+function comparePerformance(current, baseline, maxDegradationPct = 10) {
+  const latencyDeltaPct = Math.round(((current.avgLatencyUs - baseline.avgLatencyUs) / baseline.avgLatencyUs) * 100);
+  const memoryDeltaPct = Math.round(((current.heapUsedMb - baseline.heapUsedMb) / (baseline.heapUsedMb || 1)) * 100);
+
+  const hasLatencyRegression = latencyDeltaPct > maxDegradationPct;
+  const hasMemoryRegression = memoryDeltaPct > (maxDegradationPct * 2); // 20% tolerância para GC jitter
+  const passed = !hasLatencyRegression && !hasMemoryRegression;
+
+  return {
+    passed,
+    verdict: passed ? 'APROVADO' : 'REGRESSÃO_DETECTADA',
+    thresholdPct: maxDegradationPct,
+    current,
+    baseline,
+    deltas: {
+      latencyDeltaPct,
+      memoryDeltaPct
+    }
+  };
+}
+
+function formatPerfReport(comparison) {
+  let report = '================================================================================\n';
+  report += `RELATÓRIO DE PERFORMANCE & REGRESSÃO DE CI: [ ${comparison.verdict} ]\n`;
+  report += '================================================================================\n\n';
+
+  report += `Limiar Máximo de Degradação Permitido: ${comparison.thresholdPct}%\n\n`;
+
+  report += 'MÉTRICAS COMPARATIVAS:\n';
+  report += `- Latência Média por Operação: ${comparison.current.avgLatencyUs}µs (Baseline: ${comparison.baseline.avgLatencyUs}µs) -> Variação: ${comparison.deltas.latencyDeltaPct > 0 ? '+' : ''}${comparison.deltas.latencyDeltaPct}%\n`;
+  report += `- Throughput (Ops/sec): ${comparison.current.opsPerSec} ops/s (Baseline: ${comparison.baseline.opsPerSec} ops/s)\n`;
+  report += `- Memória Heap Utilizada: ${comparison.current.heapUsedMb} MB (Baseline: ${comparison.baseline.heapUsedMb} MB) -> Variação: ${comparison.deltas.memoryDeltaPct > 0 ? '+' : ''}${comparison.deltas.memoryDeltaPct}%\n\n`;
+
+  if (comparison.passed) {
+    report += 'STATUS: Nenhuma degradação crítica detectada. Aprovado para merge na esteira de CI.\n';
+  } else {
+    report += 'ALERTA SRE: Regressão superior a 10% identificada! Merge bloqueado conforme política DevSecOps.\n';
+  }
+
+  report += '================================================================================\n';
+  return report;
+}
+
+function getOrInitBaseline() {
+  const benchDir = path.dirname(BASELINE_FILE);
+  if (!fs.existsSync(benchDir)) {
+    fs.mkdirSync(benchDir, { recursive: true });
+  }
+
+  if (fs.existsSync(BASELINE_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(BASELINE_FILE, 'utf8'));
+    } catch (err) {
+      void err;
+    }
+  }
+
+  // Baseline padrão de referência calibrado para Node.js 22
+  const initialBaseline = {
+    iterations: 100,
+    totalDurationMs: 15.0,
+    avgLatencyUs: 60,
+    opsPerSec: 15000,
+    heapUsedMb: 18.5
+  };
+
+  fs.writeFileSync(BASELINE_FILE, JSON.stringify(initialBaseline, null, 2), 'utf8');
+  return initialBaseline;
+}
+
+async function runCli() {
+  const args = process.argv.slice(2);
+  const baseline = getOrInitBaseline();
+  const current = runBenchmark(100);
+
+  if (args.includes('--save-baseline')) {
+    fs.writeFileSync(BASELINE_FILE, JSON.stringify(current, null, 2), 'utf8');
+    console.log(`[Perf Scanner] Novo baseline salvo com sucesso em ${BASELINE_FILE}`);
+    return;
+  }
+
+  const comparison = comparePerformance(current, baseline, 15);
+  const report = formatPerfReport(comparison);
+  console.log(report);
+
+  if (args.includes('--strict') && !comparison.passed) {
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  runCli().catch(err => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+function auditToSarif(iterations = 50, thresholdPct = 15) {
+  const baseline = getOrInitBaseline();
+  const current = runBenchmark(iterations);
+  const comparison = comparePerformance(current, baseline, thresholdPct);
+  const findings = [];
+
+  if (!comparison.passed) {
+    findings.push({
+      ruleId: 'RULE-PERF-001',
+      name: 'PerformanceRegressionDetected',
+      severity: 'WARNING',
+      message: `Regressão de performance detectada: Latência +${comparison.deltas.latencyDeltaPct}% (Limiar: ${thresholdPct}%).`,
+      remediation: 'Investigue o overhead recente ou recalibre o baseline em benchmarks/baseline.json.'
+    });
+  }
+
+  return createSarifReport({
+    toolName: 'agent-master-perf-benchmark',
+    rules: [
+      {
+        id: 'RULE-PERF-001',
+        name: 'PerformanceRegressionDetected',
+        description: 'Bloqueia merges com regressão de latência ou memória superior ao limiar permitido',
+        severity: 'MEDIUM',
+        cwe: 'CWE-400'
+      }
+    ],
+    findings,
+    properties: {
+      passed: comparison.passed,
+      avgLatencyUs: current.avgLatencyUs,
+      baselineLatencyUs: baseline.avgLatencyUs,
+      opsPerSec: current.opsPerSec
+    }
+  });
+}
+
+class PerfBenchmark {
+  static runBenchmark(iterations) {
+    return runBenchmark(iterations);
+  }
+  static comparePerformance(current, baseline, threshold) {
+    return comparePerformance(current, baseline, threshold);
+  }
+  static formatReport(comparison) {
+    return formatPerfReport(comparison);
+  }
+  static auditToSarif(iterations, threshold) {
+    return auditToSarif(iterations, threshold);
+  }
+}
+
+module.exports = {
+  PerfBenchmark,
+  runBenchmark,
+  comparePerformance,
+  formatPerfReport,
+  formatReport: formatPerfReport,
+  auditToSarif,
+  getOrInitBaseline,
+  BASELINE_FILE
+};
+

package/scripts/core/sarif_engine.js

@@ -0,0 +1,299 @@
+/**
+ * scripts/core/sarif_engine.js
+ * Motor Canônico de Ingestão, Geração e Validação de SARIF v2.1.0
+ * (Static Analysis Results Interchange Format - OASIS Standard)
+ * 
+ * Permite interoperabilidade com GitHub Code Scanning, SonarQube,
+ * GitLab SAST, VS Code SARIF Viewer e ferramentas industriais (Semgrep, Trivy, CodeQL).
+ */
+'use strict';
+
+const SARIF_SCHEMA = 'https://json.schemastore.org/sarif-2.1.0.json';
+const SARIF_VERSION = '2.1.0';
+
+/**
+ * Mapeia níveis de severidade industriais para os níveis do padrão SARIF.
+ * @param {string} severity 
+ * @returns {'error' | 'warning' | 'note' | 'none'}
+ */
+function mapSeverityToSarifLevel(severity) {
+  const s = String(severity || '').toUpperCase();
+  if (s === 'CRITICAL' || s === 'CRÍTICA' || s === 'HIGH' || s === 'ALTA' || s === 'ERROR') {
+    return 'error';
+  }
+  if (s === 'MEDIUM' || s === 'MÉDIA' || s === 'WARNING' || s === 'MODERATE') {
+    return 'warning';
+  }
+  if (s === 'LOW' || s === 'BAIXA' || s === 'NOTE' || s === 'INFO') {
+    return 'note';
+  }
+  return 'warning';
+}
+
+/**
+ * Mapeia o nível SARIF de volta para a taxonomia padrão DevSecOps.
+ * @param {string} level 
+ * @returns {'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'INFO'}
+ */
+function mapSarifLevelToSeverity(level) {
+  const l = String(level || '').toLowerCase();
+  if (l === 'error') return 'HIGH';
+  if (l === 'warning') return 'MEDIUM';
+  if (l === 'note') return 'LOW';
+  return 'INFO';
+}
+
+/**
+ * Cria um relatório SARIF v2.1.0 oficial.
+ * @param {object} params
+ * @param {string} params.toolName
+ * @param {string} [params.toolVersion='5.1.0']
+ * @param {string} [params.informationUri]
+ * @param {Array<object>} [params.rules=[]]
+ * @param {Array<object>} params.findings
+ * @param {object} [params.properties={}]
+ * @returns {object} SARIF v2.1.0 JSON object
+ */
+function createSarifReport({
+  toolName = 'agent-master-devsecops',
+  toolVersion = '5.1.0',
+  informationUri = 'https://github.com/ContalApps/agent-master-devsecops',
+  rules = [],
+  findings = [],
+  properties = {}
+}) {
+  const ruleMap = new Map();
+
+  // Registra regras pré-definidas
+  for (const r of rules) {
+    const id = r.id || r.ruleId;
+    if (id && !ruleMap.has(id)) {
+      ruleMap.set(id, {
+        id,
+        name: r.name || id,
+        shortDescription: { text: r.name || id },
+        fullDescription: { text: r.message || r.description || id },
+        defaultConfiguration: {
+          level: mapSeverityToSarifLevel(r.severity)
+        },
+        help: {
+          text: r.remediation || r.recommendation || 'Consulte a documentação da regra para correção.'
+        },
+        properties: {
+          cwe: r.cwe || 'CWE-Unknown',
+          precision: 'high'
+        }
+      });
+    }
+  }
+
+  // Mapeia findings para results do SARIF
+  const results = findings.map((f, idx) => {
+    const ruleId = f.ruleId || f.id || `RULE-${idx + 1}`;
+    const level = mapSeverityToSarifLevel(f.severity);
+
+    // Se a regra não existia na lista, registra dinamicamente
+    if (!ruleMap.has(ruleId)) {
+      ruleMap.set(ruleId, {
+        id: ruleId,
+        name: f.name || ruleId,
+        shortDescription: { text: f.name || ruleId },
+        defaultConfiguration: { level },
+        properties: {
+          cwe: f.cwe || (f.cve ? 'CVE-Dependency' : 'CWE-Unknown')
+        }
+      });
+    }
+
+    const artifactUri = (f.filename || f.path || f.package || 'unknown').replace(/\\/g, '/');
+    const startLine = Number(f.line) > 0 ? Number(f.line) : 1;
+    const startColumn = Number(f.column) > 0 ? Number(f.column) : 1;
+
+    const resultObj = {
+      ruleId,
+      level,
+      message: {
+        text: f.message || f.description || `Violação detectada: ${ruleId}`
+      },
+      locations: [
+        {
+          physicalLocation: {
+            artifactLocation: {
+              uri: artifactUri,
+              uriBaseId: '%SRCROOT%'
+            },
+            region: {
+              startLine,
+              startColumn,
+              snippet: {
+                text: f.snippet || ''
+              }
+            }
+          }
+        }
+      ],
+      properties: {
+        cwe: f.cwe || null,
+        cve: f.cve || null,
+        remediation: f.remediation || f.recommendation || null,
+        package: f.package || null,
+        installedVersion: f.installedVersion || null
+      }
+    };
+
+    return resultObj;
+  });
+
+  return {
+    $schema: SARIF_SCHEMA,
+    version: SARIF_VERSION,
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: toolName,
+            version: toolVersion,
+            informationUri,
+            rules: Array.from(ruleMap.values())
+          }
+        },
+        results,
+        properties: {
+          ...properties,
+          generatedAt: new Date().toISOString()
+        }
+      }
+    ]
+  };
+}
+
+/**
+ * Valida a integridade estrutural mínima de um objeto SARIF v2.1.0.
+ * @param {object} sarifObj 
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+function validateSarif(sarifObj) {
+  const errors = [];
+  if (!sarifObj || typeof sarifObj !== 'object') {
+    return { valid: false, errors: ['O payload SARIF deve ser um objeto JSON válido.'] };
+  }
+  if (sarifObj.version !== '2.1.0') {
+    errors.push(`Versão SARIF inválida: esperado '2.1.0', recebido '${sarifObj.version}'.`);
+  }
+  if (!Array.isArray(sarifObj.runs)) {
+    errors.push("Propriedade 'runs' obrigatória do SARIF ausente ou não é um array.");
+  } else {
+    sarifObj.runs.forEach((run, idx) => {
+      if (!run.tool || !run.tool.driver || !run.tool.driver.name) {
+        errors.push(`Run #${idx} não possui tool.driver.name definido.`);
+      }
+      if (!Array.isArray(run.results)) {
+        errors.push(`Run #${idx} não possui 'results' como array.`);
+      }
+    });
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Ingestão e normalização de qualquer relatório SARIF v2.1.0 (Semgrep, Trivy, CodeQL, etc).
+ * @param {string|object} sarifInput 
+ * @returns {{ toolName: string, totalFindings: number, findings: Array<object> }}
+ */
+function parseSarifReport(sarifInput) {
+  let sarif;
+  if (typeof sarifInput === 'string') {
+    sarif = JSON.parse(sarifInput);
+  } else {
+    sarif = sarifInput;
+  }
+
+  const validation = validateSarif(sarif);
+  if (!validation.valid) {
+    throw new Error(`SARIF Inválido: ${validation.errors.join('; ')}`);
+  }
+
+  const allFindings = [];
+  let primaryToolName = 'unknown-tool';
+
+  for (const run of sarif.runs) {
+    const driver = run.tool?.driver || {};
+    primaryToolName = driver.name || primaryToolName;
+    const rulesList = driver.rules || [];
+    const ruleDict = new Map();
+    for (const r of rulesList) {
+      if (r.id) ruleDict.set(r.id, r);
+    }
+
+    const results = run.results || [];
+    for (const res of results) {
+      const rule = ruleDict.get(res.ruleId) || {};
+      const loc = res.locations?.[0]?.physicalLocation || {};
+      const uri = loc.artifactLocation?.uri || 'unknown';
+      const region = loc.region || {};
+
+      allFindings.push({
+        ruleId: res.ruleId,
+        name: rule.name || rule.shortDescription?.text || res.ruleId,
+        level: res.level || 'warning',
+        severity: mapSarifLevelToSeverity(res.level),
+        cwe: res.properties?.cwe || rule.properties?.cwe || 'CWE-Unknown',
+        cve: res.properties?.cve || null,
+        filename: uri,
+        line: region.startLine || 1,
+        column: region.startColumn || 1,
+        snippet: region.snippet?.text || '',
+        message: res.message?.text || '',
+        remediation: res.properties?.remediation || rule.help?.text || null,
+        rawResult: res
+      });
+    }
+  }
+
+  return {
+    toolName: primaryToolName,
+    totalFindings: allFindings.length,
+    findings: allFindings
+  };
+}
+
+/**
+ * Combina múltiplos relatórios SARIF em um documento unificado.
+ * @param {Array<object>} sarifReports 
+ * @param {string} [unifiedToolName='agent-master-devsecops-unified']
+ * @returns {object} SARIF consolidado
+ */
+function mergeSarifReports(sarifReports, unifiedToolName = 'agent-master-devsecops-unified') {
+  const mergedRuns = [];
+  for (const report of sarifReports) {
+    if (report && Array.isArray(report.runs)) {
+      mergedRuns.push(...report.runs);
+    }
+  }
+
+  return {
+    $schema: SARIF_SCHEMA,
+    version: SARIF_VERSION,
+    runs: mergedRuns.length > 0 ? mergedRuns : [
+      {
+        tool: { driver: { name: unifiedToolName, version: '5.1.0' } },
+        results: []
+      }
+    ]
+  };
+}
+
+module.exports = {
+  SARIF_SCHEMA,
+  SARIF_VERSION,
+  mapSeverityToSarifLevel,
+  mapSarifLevelToSeverity,
+  createSarifReport,
+  validateSarif,
+  parseSarifReport,
+  mergeSarifReports
+};