pumuki 6.3.7

package/integrations/mcp/evidenceFacetsBase.ts

@@ -0,0 +1,94 @@
+import type { AiEvidenceV2_1 } from '../evidence/schema';
+export const sortRulesets = (rulesets: AiEvidenceV2_1['rulesets']): AiEvidenceV2_1['rulesets'] => {
+  return [...rulesets].sort((left, right) => {
+    const byPlatform = left.platform.localeCompare(right.platform);
+    if (byPlatform !== 0) {
+      return byPlatform;
+    }
+    const byBundle = left.bundle.localeCompare(right.bundle);
+    if (byBundle !== 0) {
+      return byBundle;
+    }
+    return left.hash.localeCompare(right.hash);
+  });
+};
+
+export const sortPlatforms = (platforms: AiEvidenceV2_1['platforms']) => {
+  return Object.entries(platforms)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([platform, state]) => ({
+      platform,
+      detected: state.detected,
+      confidence: state.confidence,
+    }));
+};
+
+export const severityOrder = ['CRITICAL', 'ERROR', 'WARN', 'INFO'] as const;
+export const severityRank: Record<string, number> = {
+  CRITICAL: 0,
+  ERROR: 1,
+  WARN: 2,
+  INFO: 3,
+};
+
+export const toSeverityCounts = (
+  findings: AiEvidenceV2_1['snapshot']['findings']
+): Record<string, number> => {
+  const counts = new Map<string, number>();
+  for (const finding of findings) {
+    const key = finding.severity.toUpperCase();
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+
+  const orderedEntries = [...counts.entries()].sort(([left], [right]) => {
+    const leftIndex = severityOrder.indexOf(left as (typeof severityOrder)[number]);
+    const rightIndex = severityOrder.indexOf(right as (typeof severityOrder)[number]);
+    const normalizedLeft = leftIndex === -1 ? Number.MAX_SAFE_INTEGER : leftIndex;
+    const normalizedRight = rightIndex === -1 ? Number.MAX_SAFE_INTEGER : rightIndex;
+    if (normalizedLeft !== normalizedRight) {
+      return normalizedLeft - normalizedRight;
+    }
+    return left.localeCompare(right);
+  });
+
+  return Object.fromEntries(orderedEntries);
+};
+
+export const toRulesetsByPlatform = (rulesets: AiEvidenceV2_1['rulesets']): Record<string, number> => {
+  const counts = new Map<string, number>();
+  for (const ruleset of rulesets) {
+    counts.set(ruleset.platform, (counts.get(ruleset.platform) ?? 0) + 1);
+  }
+  return Object.fromEntries([...counts.entries()].sort(([left], [right]) => left.localeCompare(right)));
+};
+
+export const toRulesetsFingerprint = (rulesets: AiEvidenceV2_1['rulesets']): string => {
+  return sortRulesets(rulesets)
+    .map((ruleset) => ruleset.hash)
+    .join('|');
+};
+
+export const toRulesetsBundlesCount = (rulesets: AiEvidenceV2_1['rulesets']): number => {
+  const bundles = new Set<string>();
+  for (const ruleset of rulesets) {
+    bundles.add(ruleset.bundle);
+  }
+  return bundles.size;
+};
+
+export const toRulesetsPlatformsCount = (rulesets: AiEvidenceV2_1['rulesets']): number => {
+  const platforms = new Set<string>();
+  for (const ruleset of rulesets) {
+    platforms.add(ruleset.platform);
+  }
+  return platforms.size;
+};
+
+export const toRulesetsHashesCount = (rulesets: AiEvidenceV2_1['rulesets']): number => {
+  const hashes = new Set<string>();
+  for (const ruleset of rulesets) {
+    hashes.add(ruleset.hash);
+  }
+  return hashes.size;
+};
+

package/integrations/mcp/evidenceFacetsSnapshot.ts

@@ -0,0 +1,104 @@
+import type { AiEvidenceV2_1 } from '../evidence/schema';
+import { severityRank } from './evidenceFacetsBase';
+import { inferPlatformFromFilePath } from './evidenceFacetsSuppressed';
+export const toFindingsFilesCount = (findings: AiEvidenceV2_1['snapshot']['findings']): number => {
+  const files = new Set<string>();
+  for (const finding of findings) {
+    files.add(finding.file);
+  }
+  return files.size;
+};
+
+export const toFindingsRulesCount = (findings: AiEvidenceV2_1['snapshot']['findings']): number => {
+  const rules = new Set<string>();
+  for (const finding of findings) {
+    rules.add(finding.ruleId);
+  }
+  return rules.size;
+};
+
+export const toFindingsWithLinesCount = (findings: AiEvidenceV2_1['snapshot']['findings']): number => {
+  let count = 0;
+  for (const finding of findings) {
+    if (finding.lines && Array.isArray(finding.lines) && finding.lines.length > 0) {
+      count += 1;
+    }
+  }
+  return count;
+};
+
+export const toPlatformConfidenceCounts = (
+  platforms: AiEvidenceV2_1['platforms']
+): Record<string, number> => {
+  const counts = new Map<string, number>();
+  for (const entry of Object.values(platforms)) {
+    counts.set(entry.confidence, (counts.get(entry.confidence) ?? 0) + 1);
+  }
+  return Object.fromEntries([...counts.entries()].sort(([left], [right]) => left.localeCompare(right)));
+};
+
+export const toFindingsByPlatform = (
+  findings: AiEvidenceV2_1['snapshot']['findings']
+): Record<string, number> => {
+  const counts = new Map<string, number>();
+  for (const finding of findings) {
+    const platform = inferPlatformFromFilePath(finding.file);
+    counts.set(platform, (counts.get(platform) ?? 0) + 1);
+  }
+  return Object.fromEntries([...counts.entries()].sort(([left], [right]) => left.localeCompare(right)));
+};
+
+export const toLedgerByPlatform = (ledger: AiEvidenceV2_1['ledger']): Record<string, number> => {
+  const counts = new Map<string, number>();
+  for (const entry of ledger) {
+    const platform = inferPlatformFromFilePath(entry.file);
+    counts.set(platform, (counts.get(platform) ?? 0) + 1);
+  }
+  return Object.fromEntries([...counts.entries()].sort(([left], [right]) => left.localeCompare(right)));
+};
+
+export const toLedgerFilesCount = (ledger: AiEvidenceV2_1['ledger']): number => {
+  const files = new Set<string>();
+  for (const entry of ledger) {
+    files.add(entry.file);
+  }
+  return files.size;
+};
+
+export const toLedgerRulesCount = (ledger: AiEvidenceV2_1['ledger']): number => {
+  const rules = new Set<string>();
+  for (const entry of ledger) {
+    rules.add(entry.ruleId);
+  }
+  return rules.size;
+};
+
+export const toHighestSeverity = (
+  findings: AiEvidenceV2_1['snapshot']['findings']
+): string | null => {
+  let highest: string | null = null;
+  for (const finding of findings) {
+    const severity = finding.severity.toUpperCase();
+    if (highest === null) {
+      highest = severity;
+      continue;
+    }
+    const currentRank = severityRank[severity] ?? Number.MAX_SAFE_INTEGER;
+    const highestRank = severityRank[highest] ?? Number.MAX_SAFE_INTEGER;
+    if (currentRank < highestRank) {
+      highest = severity;
+    }
+  }
+  return highest;
+};
+
+export const toBlockingFindingsCount = (findings: AiEvidenceV2_1['snapshot']['findings']): number => {
+  let count = 0;
+  for (const finding of findings) {
+    const rank = severityRank[finding.severity.toUpperCase()] ?? Number.MAX_SAFE_INTEGER;
+    if (rank <= severityRank.ERROR) {
+      count += 1;
+    }
+  }
+  return count;
+};

package/integrations/mcp/evidenceFacetsSuppressed.ts

@@ -0,0 +1,3 @@
+export * from './evidenceFacetsSuppressedBase';
+export * from './evidenceFacetsSuppressedRelations';
+export * from './evidenceFacetsSuppressedShare';

package/integrations/mcp/evidenceFacetsSuppressedBase.ts

@@ -0,0 +1,221 @@
+import type { AiEvidenceV2_1 } from '../evidence/schema';
+import {
+  toSuppressedNonReplacementPlatformsCount,
+  toSuppressedReplacementPlatformsCount,
+  toSuppressedWithoutReplacementPlatformsCount,
+} from './evidenceFacetsSuppressedRelations';
+
+const toRoundedRatioPct = (numerator: number, denominator: number): number => {
+  if (denominator === 0) {
+    return 0;
+  }
+  return Math.round((numerator / denominator) * 100);
+};
+
+export const toSuppressedReplacementRulesCount = (evidence: AiEvidenceV2_1): number => {
+  const replacements = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    replacements.add(entry.replacedByRuleId);
+  }
+  return replacements.size;
+};
+
+export const toSuppressedRulesCount = (evidence: AiEvidenceV2_1): number => {
+  const rules = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    rules.add(entry.ruleId);
+  }
+  return rules.size;
+};
+
+export const toSuppressedReplacementRulesRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const replacementRules = toSuppressedReplacementRulesCount(evidence);
+  const suppressedRules = toSuppressedRulesCount(evidence);
+  return toRoundedRatioPct(replacementRules, suppressedRules);
+};
+
+export const toSuppressedNonReplacementRulesCount = (evidence: AiEvidenceV2_1): number => {
+  const rules = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      rules.add(entry.ruleId);
+    }
+  }
+  return rules.size;
+};
+
+export const toSuppressedNonReplacementRulesRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const nonReplacementRules = toSuppressedNonReplacementRulesCount(evidence);
+  const suppressedRules = toSuppressedRulesCount(evidence);
+  return toRoundedRatioPct(nonReplacementRules, suppressedRules);
+};
+
+export const inferPlatformFromFilePath = (
+  filePath: string
+): 'ios' | 'backend' | 'frontend' | 'android' | 'generic' => {
+  const file = filePath.toLowerCase();
+  if (file.startsWith('apps/ios/') || file.endsWith('.swift')) {
+    return 'ios';
+  }
+  if (file.startsWith('apps/backend/')) {
+    return 'backend';
+  }
+  if (file.startsWith('apps/frontend/')) {
+    return 'frontend';
+  }
+  if (file.startsWith('apps/android/') || file.endsWith('.kt') || file.endsWith('.kts')) {
+    return 'android';
+  }
+  return 'generic';
+};
+
+export const toSuppressedPlatformsCount = (evidence: AiEvidenceV2_1): number => {
+  const platforms = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    platforms.add(inferPlatformFromFilePath(entry.file));
+  }
+  return platforms.size;
+};
+
+export const toSuppressedFilesCount = (evidence: AiEvidenceV2_1): number => {
+  const files = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    files.add(entry.file);
+  }
+  return files.size;
+};
+
+export const toSuppressedReasonsCount = (evidence: AiEvidenceV2_1): number => {
+  const reasons = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    reasons.add(entry.reason);
+  }
+  return reasons.size;
+};
+
+export const toSuppressedWithReplacementCount = (evidence: AiEvidenceV2_1): number => {
+  let count = 0;
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      count += 1;
+    }
+  }
+  return count;
+};
+
+export const toSuppressedWithReplacementFilesCount = (evidence: AiEvidenceV2_1): number => {
+  const files = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null || entry.replacedByRuleId.length > 0) {
+      files.add(entry.file);
+    }
+  }
+  return files.size;
+};
+
+export const toSuppressedWithReplacementPlatformsCount = (evidence: AiEvidenceV2_1): number => {
+  const platforms = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null || entry.replacedByRuleId.length > 0) {
+      platforms.add(entry.platform ?? '');
+    }
+  }
+  return platforms.size;
+};
+
+export const toSuppressedWithoutReplacementFilesCount = (evidence: AiEvidenceV2_1): number => {
+  const files = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null && entry.replacedByRuleId.length === 0) {
+      files.add(entry.file);
+    }
+  }
+  return files.size;
+};
+
+export const toSuppressedNonReplacementFilesCount = (evidence: AiEvidenceV2_1): number => {
+  const files = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      files.add(entry.file);
+    }
+  }
+  return files.size;
+};
+
+export const toSuppressedWithReplacementFilesRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const totalFiles = toSuppressedFilesCount(evidence);
+  return toRoundedRatioPct(toSuppressedWithReplacementFilesCount(evidence), totalFiles);
+};
+
+export const toSuppressedReplacementFilesRatioPct = (evidence: AiEvidenceV2_1): number =>
+  toSuppressedWithReplacementFilesRatioPct(evidence);
+
+export const toSuppressedWithoutReplacementFilesRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const totalFiles = toSuppressedFilesCount(evidence);
+  return toRoundedRatioPct(toSuppressedWithoutReplacementFilesCount(evidence), totalFiles);
+};
+
+export const toSuppressedNonReplacementFilesRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const totalFiles = toSuppressedFilesCount(evidence);
+  return toRoundedRatioPct(toSuppressedNonReplacementFilesCount(evidence), totalFiles);
+};
+
+export const toSuppressedWithReplacementPlatformsRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const totalPlatforms = toSuppressedPlatformsCount(evidence);
+  return toRoundedRatioPct(toSuppressedWithReplacementPlatformsCount(evidence), totalPlatforms);
+};
+
+export const toSuppressedWithoutReplacementPlatformsRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const totalPlatforms = toSuppressedPlatformsCount(evidence);
+  return toRoundedRatioPct(toSuppressedWithoutReplacementPlatformsCount(evidence), totalPlatforms);
+};
+
+export const toSuppressedNonReplacementPlatformsRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const totalPlatforms = toSuppressedPlatformsCount(evidence);
+  return toRoundedRatioPct(toSuppressedNonReplacementPlatformsCount(evidence), totalPlatforms);
+};
+
+export const toSuppressedReplacementPlatformsRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const totalPlatforms = toSuppressedPlatformsCount(evidence);
+  return toRoundedRatioPct(toSuppressedReplacementPlatformsCount(evidence), totalPlatforms);
+};
+
+export const toSuppressedWithReplacementRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const total = evidence.consolidation?.suppressed?.length ?? 0;
+  return toRoundedRatioPct(toSuppressedWithReplacementCount(evidence), total);
+};
+
+export const toSuppressedFindingCoverageRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const suppressedFindingsCount = evidence.consolidation?.suppressed?.length ?? 0;
+  const findingUniverseSize =
+    suppressedFindingsCount + evidence.snapshot.findings.length;
+  return toRoundedRatioPct(suppressedFindingsCount, findingUniverseSize);
+};
+
+export const toSuppressedWithoutReplacementCount = (evidence: AiEvidenceV2_1): number => {
+  let count = 0;
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      count += 1;
+    }
+  }
+  return count;
+};
+
+export const toSuppressedNonReplacementRatioPct = (evidence: AiEvidenceV2_1): number => {
+  return toSuppressedWithoutReplacementRatioPct(evidence);
+};
+
+export const toSuppressedWithoutReplacementRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const total = evidence.consolidation?.suppressed?.length ?? 0;
+  return toRoundedRatioPct(toSuppressedWithoutReplacementCount(evidence), total);
+};
+
+export const toSuppressedReasonsCoverageRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const suppressedFindingsCount = evidence.consolidation?.suppressed?.length ?? 0;
+  const reasonsCount = toSuppressedReasonsCount(evidence);
+  return toRoundedRatioPct(reasonsCount, suppressedFindingsCount);
+};
+
+

package/integrations/mcp/evidenceFacetsSuppressedRelations.ts

@@ -0,0 +1,263 @@
+import type { AiEvidenceV2_1 } from '../evidence/schema';
+
+const toSuppressedReasonsCountLocal = (evidence: AiEvidenceV2_1): number => {
+  const reasons = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    reasons.add(entry.reason);
+  }
+  return reasons.size;
+};
+
+export const toSuppressedRuleFilePairsCount = (evidence: AiEvidenceV2_1): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    pairs.add(`${entry.ruleId}:${entry.file}`);
+  }
+  return pairs.size;
+};
+
+export const toSuppressedReasonsWithReplacementCount = (evidence: AiEvidenceV2_1): number => {
+  const reasons = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      reasons.add(entry.reason);
+    }
+  }
+  return reasons.size;
+};
+
+export const toSuppressedReasonsWithReplacementRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const reasonsWithReplacement = toSuppressedReasonsWithReplacementCount(evidence);
+  const reasonsCount = toSuppressedReasonsCountLocal(evidence);
+  if (reasonsCount === 0) {
+    return 0;
+  }
+  return Math.round((reasonsWithReplacement / reasonsCount) * 100);
+};
+
+export const toSuppressedReasonsWithoutReplacementCount = (evidence: AiEvidenceV2_1): number => {
+  const reasons = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      reasons.add(entry.reason);
+    }
+  }
+  return reasons.size;
+};
+
+export const toSuppressedReasonsWithoutReplacementRatioPct = (evidence: AiEvidenceV2_1): number => {
+  const reasonsWithoutReplacement = toSuppressedReasonsWithoutReplacementCount(evidence);
+  const reasonsCount = toSuppressedReasonsCountLocal(evidence);
+  if (reasonsCount === 0) {
+    return 0;
+  }
+  return Math.round((reasonsWithoutReplacement / reasonsCount) * 100);
+};
+
+export const toSuppressedPlatformRulePairsCount = (evidence: AiEvidenceV2_1): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    pairs.add(`${entry.platform}:${entry.ruleId}`);
+  }
+  return pairs.size;
+};
+
+export const toSuppressedPlatformFilePairsCount = (evidence: AiEvidenceV2_1): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    pairs.add(`${entry.platform}:${entry.file}`);
+  }
+  return pairs.size;
+};
+
+export const toSuppressedReplacementRuleFilePairsCount = (evidence: AiEvidenceV2_1): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      pairs.add(`${entry.replacementRuleId}:${entry.file}`);
+    }
+  }
+  return pairs.size;
+};
+
+export const toSuppressedReplacementRuleFilePairsRatioPct = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const replacementRuleFilePairs = toSuppressedReplacementRuleFilePairsCount(evidence);
+  const totalRuleFilePairs = toSuppressedRuleFilePairsCount(evidence);
+  if (totalRuleFilePairs === 0) {
+    return 0;
+  }
+  return Math.round((replacementRuleFilePairs / totalRuleFilePairs) * 100);
+};
+
+export const toSuppressedReplacementRulePlatformPairsCount = (evidence: AiEvidenceV2_1): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      pairs.add(`${entry.replacementRuleId}:${entry.platform}`);
+    }
+  }
+  return pairs.size;
+};
+
+export const toSuppressedReplacementRulePlatformPairsRatioPct = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const replacementRulePlatformPairs = toSuppressedReplacementRulePlatformPairsCount(evidence);
+  const totalRulePlatformPairs = toSuppressedPlatformRulePairsCount(evidence);
+  if (totalRulePlatformPairs === 0) {
+    return 0;
+  }
+  return Math.round((replacementRulePlatformPairs / totalRulePlatformPairs) * 100);
+};
+
+export const toSuppressedReplacementPlatformsCount = (evidence: AiEvidenceV2_1): number => {
+  const platforms = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      platforms.add(entry.platform ?? '');
+    }
+  }
+  return platforms.size;
+};
+
+export const toSuppressedNonReplacementPlatformsCount = (evidence: AiEvidenceV2_1): number => {
+  const platforms = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      platforms.add(entry.platform ?? '');
+    }
+  }
+  return platforms.size;
+};
+
+export const toSuppressedWithoutReplacementPlatformsCount = (evidence: AiEvidenceV2_1): number => {
+  const platforms = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if ((entry.replacementRuleId === null || entry.replacementRuleId === undefined) && entry.replacedByRuleId.length === 0) {
+      platforms.add(entry.platform ?? '');
+    }
+  }
+  return platforms.size;
+};
+
+export const toSuppressedNonReplacementReasonFilePairsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      pairs.add(`${entry.reason}:${entry.file}`);
+    }
+  }
+  return pairs.size;
+};
+
+export const toSuppressedNonReplacementRuleFilePairsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      pairs.add(`${entry.ruleId}:${entry.file}`);
+    }
+  }
+  return pairs.size;
+};
+
+export const toSuppressedNonReplacementRuleFilePairsRatioPct = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const nonReplacementRuleFilePairs = toSuppressedNonReplacementRuleFilePairsCount(evidence);
+  const totalRuleFilePairs = toSuppressedRuleFilePairsCount(evidence);
+  if (totalRuleFilePairs === 0) {
+    return 0;
+  }
+  return Math.round((nonReplacementRuleFilePairs / totalRuleFilePairs) * 100);
+};
+
+export const toSuppressedNonReplacementRulePlatformPairsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      pairs.add(`${entry.ruleId}:${entry.platform}`);
+    }
+  }
+  return pairs.size;
+};
+
+export const toSuppressedNonReplacementRulePlatformPairsRatioPct = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const nonReplacementRulePlatformPairs = toSuppressedNonReplacementRulePlatformPairsCount(evidence);
+  const totalRulePlatformPairs = toSuppressedPlatformRulePairsCount(evidence);
+  if (totalRulePlatformPairs === 0) {
+    return 0;
+  }
+  return Math.round((nonReplacementRulePlatformPairs / totalRulePlatformPairs) * 100);
+};
+
+export const toSuppressedNonReplacementReasonsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const reasons = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId === null) {
+      reasons.add(entry.reason);
+    }
+  }
+  return reasons.size;
+};
+
+export const toSuppressedReplacementReasonFilePairsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      pairs.add(`${entry.reason}:${entry.file}`);
+    }
+  }
+  return pairs.size;
+};
+
+export const toSuppressedReplacementRuleReasonPairsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const pairs = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      pairs.add(`${entry.replacementRuleId}:${entry.reason}`);
+    }
+  }
+  return pairs.size;
+};
+
+export const toSuppressedReplacementRuleIdsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const ruleIds = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    const replacementRuleId = entry.replacementRuleId ?? entry.replacedByRuleId;
+    if (replacementRuleId.length > 0) {
+      ruleIds.add(replacementRuleId);
+    }
+  }
+  return ruleIds.size;
+};
+
+export const toSuppressedReplacementReasonsCount = (
+  evidence: AiEvidenceV2_1,
+): number => {
+  const reasons = new Set<string>();
+  for (const entry of evidence.consolidation?.suppressed ?? []) {
+    if (entry.replacementRuleId !== null) {
+      reasons.add(entry.reason);
+    }
+  }
+  return reasons.size;
+};
+

package/integrations/mcp/evidenceFacetsSuppressedShare.ts

@@ -0,0 +1,2 @@
+export * from './evidenceFacetsSuppressedShareCore';
+export * from './evidenceFacetsSuppressedShareTriage';