Skip to content

OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security

refactor(sdk): simplify contradiction grouping state (#1202)

mldangelo-oai6cbe7c970a50
diff --git a/sdk/typescript/src/deduplication/deduplication.ts b/sdk/typescript/src/deduplication/deduplication.ts
index da952e4ea..baa54e921 100644
--- a/sdk/typescript/src/deduplication/deduplication.ts
+++ b/sdk/typescript/src/deduplication/deduplication.ts
@@ -91,48 +91,12 @@ const severityOrder: Record<Finding["severity"]["level"], number> = {
informational: 4,
};
-function scoreAfter(
- left: readonly number[],
- right: readonly number[],
-): boolean {
- for (let index = 0; index < left.length; index++) {
- if (left[index] !== right[index]) return left[index]! > right[index]!;
- }
- return false;
-}
-
/** @internal */
export interface ContradictionGroupingMetrics {
candidateEvaluations: number;
conflictNeighborChecks: number;
}
-function addSupport(
- support: Map<number, Map<number, number>>,
- left: number,
- right: number,
-): void {
- const leftSupport = support.get(left) ?? new Map<number, number>();
- const rightSupport = support.get(right) ?? new Map<number, number>();
- leftSupport.set(right, (leftSupport.get(right) ?? 0) + 1);
- rightSupport.set(left, (rightSupport.get(left) ?? 0) + 1);
- support.set(left, leftSupport);
- support.set(right, rightSupport);
-}
-
-function addConflict(
- conflicts: Map<number, Set<number>>,
- left: number,
- right: number,
-): void {
- const leftConflicts = conflicts.get(left) ?? new Set<number>();
- const rightConflicts = conflicts.get(right) ?? new Set<number>();
- leftConflicts.add(right);
- rightConflicts.add(left);
- conflicts.set(left, leftConflicts);
- conflicts.set(right, rightConflicts);
-}
-
/** Greedily retain the best-supported legal merges, using input order for ties. */
/** @internal */
export function contradictionFreeSubgroups(
@@ -145,26 +109,40 @@ export function contradictionFreeSubgroups(
const indexes = new Map(
findingIds.map((findingId, index) => [findingId, index]),
);
- const active = new Set(findingIds.map((_findingId, index) => index));
const clusters = new Map(
findingIds.map((findingId, index) => [index, new Set([findingId])]),
);
const support = new Map<number, Map<number, number>>();
- for (const [left, right] of samePairs)
- addSupport(support, indexes.get(left)!, indexes.get(right)!);
+ for (const [left, right] of samePairs) {
+ const leftIndex = indexes.get(left)!;
+ const rightIndex = indexes.get(right)!;
+ const leftSupport = support.get(leftIndex) ?? new Map<number, number>();
+ const rightSupport = support.get(rightIndex) ?? new Map<number, number>();
+ leftSupport.set(rightIndex, (leftSupport.get(rightIndex) ?? 0) + 1);
+ rightSupport.set(leftIndex, (rightSupport.get(leftIndex) ?? 0) + 1);
+ support.set(leftIndex, leftSupport);
+ support.set(rightIndex, rightSupport);
+ }
const conflicts = new Map<number, Set<number>>();
- for (const [left, right] of distinctPairs)
- addConflict(conflicts, indexes.get(left)!, indexes.get(right)!);
+ for (const [left, right] of distinctPairs) {
+ const leftIndex = indexes.get(left)!;
+ const rightIndex = indexes.get(right)!;
+ const leftConflicts = conflicts.get(leftIndex) ?? new Set<number>();
+ const rightConflicts = conflicts.get(rightIndex) ?? new Set<number>();
+ leftConflicts.add(rightIndex);
+ rightConflicts.add(leftIndex);
+ conflicts.set(leftIndex, leftConflicts);
+ conflicts.set(rightIndex, rightConflicts);
+ }
while (true) {
signal?.throwIfAborted();
let selected: readonly [number, number] | undefined;
let selectedScore: readonly number[] | undefined;
- for (const leftCluster of active) {
+ for (const leftCluster of clusters.keys()) {
for (const [rightCluster, gain] of support.get(leftCluster) ?? []) {
if (
leftCluster >= rightCluster ||
- !active.has(rightCluster) ||
conflicts.get(leftCluster)?.has(rightCluster)
)
continue;
@@ -189,55 +167,43 @@ export function contradictionFreeSubgroups(
-leftCluster,
-rightCluster,
];
- if (selectedScore === undefined || scoreAfter(score, selectedScore)) {
- selected = [leftCluster, rightCluster];
- selectedScore = score;
+ if (selectedScore !== undefined) {
+ const index = score.findIndex(
+ (value, position) => value !== selectedScore![position],
+ );
+ if (index === -1 || !(score[index]! > selectedScore[index]!)) {
+ continue;
+ }
}
+ selected = [leftCluster, rightCluster];
+ selectedScore = score;
}
}
if (selected === undefined)
- return [...active]
- .map((cluster) => clusters.get(cluster)!)
- .filter((members) => members.size > 1);
+ return [...clusters.values()].filter((members) => members.size > 1);
const [leftCluster, rightCluster] = selected;
for (const member of clusters.get(rightCluster)!)
clusters.get(leftCluster)!.add(member);
clusters.delete(rightCluster);
- active.delete(rightCluster);
- const leftSupport = support.get(leftCluster) ?? new Map<number, number>();
- const rightSupport = support.get(rightCluster) ?? new Map<number, number>();
- const supportNeighbors = new Set([
- ...leftSupport.keys(),
- ...rightSupport.keys(),
- ]);
- supportNeighbors.delete(leftCluster);
- supportNeighbors.delete(rightCluster);
+ const leftSupport = support.get(leftCluster)!;
leftSupport.delete(rightCluster);
- for (const neighbor of supportNeighbors) {
- const weight =
- (leftSupport.get(neighbor) ?? 0) + (rightSupport.get(neighbor) ?? 0);
+ for (const [neighbor, rightWeight] of support.get(rightCluster)!) {
+ if (neighbor === leftCluster || neighbor === rightCluster) continue;
+ const weight = (leftSupport.get(neighbor) ?? 0) + rightWeight;
leftSupport.set(neighbor, weight);
- const neighborSupport = support.get(neighbor)!;
- neighborSupport.delete(rightCluster);
- neighborSupport.set(leftCluster, weight);
+ support.get(neighbor)!.set(leftCluster, weight).delete(rightCluster);
}
- support.set(leftCluster, leftSupport);
support.delete(rightCluster);
- const mergedConflicts = new Set([
- ...(conflicts.get(leftCluster) ?? []),
- ...(conflicts.get(rightCluster) ?? []),
- ]);
+ const mergedConflicts = conflicts.get(leftCluster) ?? new Set<number>();
+ for (const id of conflicts.get(rightCluster) ?? []) mergedConflicts.add(id);
mergedConflicts.delete(leftCluster);
mergedConflicts.delete(rightCluster);
for (const neighbor of mergedConflicts) {
- const neighborConflicts = conflicts.get(neighbor)!;
- neighborConflicts.delete(rightCluster);
- neighborConflicts.add(leftCluster);
+ conflicts.get(neighbor)!.add(leftCluster).delete(rightCluster);
}
- if (mergedConflicts.size > 0) conflicts.set(leftCluster, mergedConflicts);
- else conflicts.delete(leftCluster);
+ conflicts.set(leftCluster, mergedConflicts);
conflicts.delete(rightCluster);
}
}