open-multi-agent-kit 0.80.6 → 0.80.7

package/dist/core/context-graph-reasoning.d.ts

@@ -0,0 +1,130 @@
+export type ContextGraphTraversalMode = "dependency" | "reverse-impact" | "neighbors" | "tests";
+export interface ContextGraphNode {
+    readonly id: string;
+    readonly reliability?: number;
+    readonly changeFrequency?: number;
+    readonly failureRate?: number;
+    readonly complexity?: number;
+    readonly centrality?: number;
+}
+export interface ContextGraphEdge {
+    readonly id?: string;
+    readonly source: string;
+    readonly target: string;
+    readonly kind?: string;
+    readonly reliability?: number;
+    readonly weight?: number;
+}
+export interface NormalizedContextGraphEdge extends ContextGraphEdge {
+    readonly id: string;
+    readonly kind: string;
+}
+export interface MultiSourceDijkstraInput {
+    readonly nodes: readonly ContextGraphNode[];
+    readonly edges: readonly ContextGraphEdge[];
+    readonly sources: readonly string[];
+    readonly mode: ContextGraphTraversalMode;
+    readonly maxCost?: number;
+}
+export interface DijkstraPredecessor {
+    readonly nodeId: string;
+    readonly edge: NormalizedContextGraphEdge;
+}
+export interface DijkstraPathStep {
+    readonly nodeId: string;
+    readonly edge: NormalizedContextGraphEdge;
+}
+export interface MultiSourceDijkstraResult {
+    readonly distances: ReadonlyMap<string, number>;
+    readonly predecessors: ReadonlyMap<string, DijkstraPredecessor>;
+    readonly paths: ReadonlyMap<string, readonly DijkstraPathStep[]>;
+    readonly nodePaths: ReadonlyMap<string, readonly string[]>;
+    readonly settledNodeIds: readonly string[];
+}
+export interface DependencyCycleInput {
+    readonly nodes: readonly ContextGraphNode[];
+    readonly edges: readonly ContextGraphEdge[];
+}
+export interface ImpactPropagationInput {
+    readonly nodes: readonly ContextGraphNode[];
+    readonly edges: readonly ContextGraphEdge[];
+    readonly changedNodeIds: readonly string[];
+    readonly threshold?: number;
+    readonly decay?: number;
+}
+export interface ImpactPropagationHit {
+    readonly nodeId: string;
+    readonly score: number;
+}
+export interface ImpactPropagationResult {
+    readonly scores: ReadonlyMap<string, number>;
+    readonly impacted: readonly ImpactPropagationHit[];
+}
+export interface SetCoverTarget {
+    readonly id: string;
+    readonly weight?: number;
+}
+export interface WeightedTestCoverage {
+    readonly targetId: string;
+    readonly weight?: number;
+}
+export type TestCoverageInput = string | WeightedTestCoverage;
+export interface TestCoverageCandidate {
+    readonly id: string;
+    readonly covers: readonly TestCoverageInput[];
+    readonly cost?: number;
+    readonly reliability?: number;
+}
+export interface GreedyWeightedSetCoverInput {
+    readonly targets: readonly SetCoverTarget[];
+    readonly tests: readonly TestCoverageCandidate[];
+}
+export interface GreedyWeightedSetCoverResult {
+    readonly selectedTests: readonly TestCoverageCandidate[];
+    readonly coveredTargetIds: readonly string[];
+    readonly uncoveredTargetIds: readonly string[];
+    readonly totalCost: number;
+    readonly totalWeightCovered: number;
+}
+export interface HotspotScoringInput {
+    readonly nodes: readonly ContextGraphNode[];
+    readonly edges: readonly ContextGraphEdge[];
+    readonly weights?: Partial<HotspotScoreWeights>;
+}
+export interface HotspotScoreWeights {
+    readonly changeFrequency: number;
+    readonly failureRate: number;
+    readonly complexity: number;
+    readonly fanIn: number;
+    readonly fanOut: number;
+    readonly reverseImpact: number;
+    readonly centrality: number;
+    readonly reliabilityRisk: number;
+}
+export interface HotspotScoreBreakdown {
+    readonly changeFrequency: number;
+    readonly failureRate: number;
+    readonly complexity: number;
+    readonly fanIn: number;
+    readonly fanOut: number;
+    readonly reverseImpact: number;
+    readonly centrality: number;
+    readonly reliabilityRisk: number;
+}
+export interface HotspotScore {
+    readonly nodeId: string;
+    readonly score: number;
+    readonly breakdown: HotspotScoreBreakdown;
+}
+export declare const reliabilityToTraversalCost: (reliability?: number) => number;
+export declare const runMultiSourceDijkstra: (input: MultiSourceDijkstraInput) => MultiSourceDijkstraResult;
+export declare const detectDependencyCycles: (input: DependencyCycleInput) => string[][];
+export declare const propagateImpact: (input: ImpactPropagationInput) => ImpactPropagationResult;
+export declare const selectTestsByGreedyWeightedSetCover: (input: GreedyWeightedSetCoverInput) => GreedyWeightedSetCoverResult;
+export declare const scoreGraphHotspots: (input: HotspotScoringInput) => HotspotScore[];
+export declare const multiSourceDijkstra: (input: MultiSourceDijkstraInput) => MultiSourceDijkstraResult;
+export declare const findDependencyCycles: (input: DependencyCycleInput) => string[][];
+export declare const propagateReverseImpact: (input: ImpactPropagationInput) => ImpactPropagationResult;
+export declare const selectTestsByWeightedSetCover: (input: GreedyWeightedSetCoverInput) => GreedyWeightedSetCoverResult;
+export declare const scoreHotspots: (input: HotspotScoringInput) => HotspotScore[];
+//# sourceMappingURL=context-graph-reasoning.d.ts.map

package/dist/core/context-graph-reasoning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-graph-reasoning.d.ts","sourceRoot":"","sources":["../../src/core/context-graph-reasoning.ts"],"names":[],"mappings":"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","sourcesContent":["export type ContextGraphTraversalMode = \"dependency\" | \"reverse-impact\" | \"neighbors\" | \"tests\";\n\nexport interface ContextGraphNode {\n\treadonly id: string;\n\treadonly reliability?: number;\n\treadonly changeFrequency?: number;\n\treadonly failureRate?: number;\n\treadonly complexity?: number;\n\treadonly centrality?: number;\n}\n\nexport interface ContextGraphEdge {\n\treadonly id?: string;\n\treadonly source: string;\n\treadonly target: string;\n\treadonly kind?: string;\n\treadonly reliability?: number;\n\treadonly weight?: number;\n}\n\nexport interface NormalizedContextGraphEdge extends ContextGraphEdge {\n\treadonly id: string;\n\treadonly kind: string;\n}\n\nexport interface MultiSourceDijkstraInput {\n\treadonly nodes: readonly ContextGraphNode[];\n\treadonly edges: readonly ContextGraphEdge[];\n\treadonly sources: readonly string[];\n\treadonly mode: ContextGraphTraversalMode;\n\treadonly maxCost?: number;\n}\n\nexport interface DijkstraPredecessor {\n\treadonly nodeId: string;\n\treadonly edge: NormalizedContextGraphEdge;\n}\n\nexport interface DijkstraPathStep {\n\treadonly nodeId: string;\n\treadonly edge: NormalizedContextGraphEdge;\n}\n\nexport interface MultiSourceDijkstraResult {\n\treadonly distances: ReadonlyMap<string, number>;\n\treadonly predecessors: ReadonlyMap<string, DijkstraPredecessor>;\n\treadonly paths: ReadonlyMap<string, readonly DijkstraPathStep[]>;\n\treadonly nodePaths: ReadonlyMap<string, readonly string[]>;\n\treadonly settledNodeIds: readonly string[];\n}\n\nexport interface DependencyCycleInput {\n\treadonly nodes: readonly ContextGraphNode[];\n\treadonly edges: readonly ContextGraphEdge[];\n}\n\nexport interface ImpactPropagationInput {\n\treadonly nodes: readonly ContextGraphNode[];\n\treadonly edges: readonly ContextGraphEdge[];\n\treadonly changedNodeIds: readonly string[];\n\treadonly threshold?: number;\n\treadonly decay?: number;\n}\n\nexport interface ImpactPropagationHit {\n\treadonly nodeId: string;\n\treadonly score: number;\n}\n\nexport interface ImpactPropagationResult {\n\treadonly scores: ReadonlyMap<string, number>;\n\treadonly impacted: readonly ImpactPropagationHit[];\n}\n\nexport interface SetCoverTarget {\n\treadonly id: string;\n\treadonly weight?: number;\n}\n\nexport interface WeightedTestCoverage {\n\treadonly targetId: string;\n\treadonly weight?: number;\n}\n\nexport type TestCoverageInput = string | WeightedTestCoverage;\n\nexport interface TestCoverageCandidate {\n\treadonly id: string;\n\treadonly covers: readonly TestCoverageInput[];\n\treadonly cost?: number;\n\treadonly reliability?: number;\n}\n\nexport interface GreedyWeightedSetCoverInput {\n\treadonly targets: readonly SetCoverTarget[];\n\treadonly tests: readonly TestCoverageCandidate[];\n}\n\nexport interface GreedyWeightedSetCoverResult {\n\treadonly selectedTests: readonly TestCoverageCandidate[];\n\treadonly coveredTargetIds: readonly string[];\n\treadonly uncoveredTargetIds: readonly string[];\n\treadonly totalCost: number;\n\treadonly totalWeightCovered: number;\n}\n\nexport interface HotspotScoringInput {\n\treadonly nodes: readonly ContextGraphNode[];\n\treadonly edges: readonly ContextGraphEdge[];\n\treadonly weights?: Partial<HotspotScoreWeights>;\n}\n\nexport interface HotspotScoreWeights {\n\treadonly changeFrequency: number;\n\treadonly failureRate: number;\n\treadonly complexity: number;\n\treadonly fanIn: number;\n\treadonly fanOut: number;\n\treadonly reverseImpact: number;\n\treadonly centrality: number;\n\treadonly reliabilityRisk: number;\n}\n\nexport interface HotspotScoreBreakdown {\n\treadonly changeFrequency: number;\n\treadonly failureRate: number;\n\treadonly complexity: number;\n\treadonly fanIn: number;\n\treadonly fanOut: number;\n\treadonly reverseImpact: number;\n\treadonly centrality: number;\n\treadonly reliabilityRisk: number;\n}\n\nexport interface HotspotScore {\n\treadonly nodeId: string;\n\treadonly score: number;\n\treadonly breakdown: HotspotScoreBreakdown;\n}\n\ninterface TraversalEdge {\n\treadonly from: string;\n\treadonly to: string;\n\treadonly edge: NormalizedContextGraphEdge;\n\treadonly cost: number;\n\treadonly direction: \"forward\" | \"reverse\";\n}\n\ninterface TestSelectionCandidate {\n\treadonly test: TestCoverageCandidate;\n\treadonly gain: number;\n\treadonly ratio: number;\n\treadonly effectiveCost: number;\n\treadonly coveredTargetIds: readonly string[];\n}\n\nconst MIN_RELIABILITY = 0.001;\nconst FLOAT_EPSILON = 1e-12;\nconst DEFAULT_HOTSPOT_WEIGHTS: HotspotScoreWeights = {\n\tchangeFrequency: 0.18,\n\tfailureRate: 0.22,\n\tcomplexity: 0.15,\n\tfanIn: 0.15,\n\tfanOut: 0.05,\n\treverseImpact: 0.15,\n\tcentrality: 0.05,\n\treliabilityRisk: 0.05,\n};\n\nexport const reliabilityToTraversalCost = (reliability = 1): number => {\n\tconst normalizedReliability = Math.max(MIN_RELIABILITY, clamp01(reliability));\n\treturn 1 / normalizedReliability;\n};\n\nexport const runMultiSourceDijkstra = (input: MultiSourceDijkstraInput): MultiSourceDijkstraResult => {\n\tconst nodeIds = collectNodeIds(input.nodes, input.edges);\n\tconst traversalEdges = buildTraversalEdges(input.edges, input.mode);\n\tconst adjacency = buildTraversalAdjacency(traversalEdges);\n\tconst sources = uniqueSorted(input.sources.map(normalizeId).filter((source) => source.length > 0));\n\tconst distances = new Map<string, number>();\n\tconst predecessors = new Map<string, DijkstraPredecessor>();\n\tconst pathKeys = new Map<string, string>();\n\tconst frontier = new Set<string>();\n\tconst settledNodeIds: string[] = [];\n\tconst maxCost = normalizePositiveNumber(input.maxCost, Number.POSITIVE_INFINITY);\n\n\tfor (const source of sources) {\n\t\tnodeIds.add(source);\n\t\tdistances.set(source, 0);\n\t\tpathKeys.set(source, source);\n\t\tfrontier.add(source);\n\t}\n\n\twhile (frontier.size > 0) {\n\t\tconst currentNodeId = pickLowestCostNode(frontier, distances, pathKeys);\n\t\tif (currentNodeId === undefined) break;\n\n\t\tfrontier.delete(currentNodeId);\n\t\tsettledNodeIds.push(currentNodeId);\n\t\tconst currentDistance = distances.get(currentNodeId) ?? Number.POSITIVE_INFINITY;\n\t\tconst currentPathKey = pathKeys.get(currentNodeId) ?? currentNodeId;\n\n\t\tfor (const traversalEdge of adjacency.get(currentNodeId) ?? []) {\n\t\t\tconst candidateDistance = currentDistance + traversalEdge.cost;\n\t\t\tif (candidateDistance > maxCost + FLOAT_EPSILON) continue;\n\n\t\t\tconst candidatePathKey = `${currentPathKey}\\0${traversalEdge.to}\\0${traversalEdge.edge.id}`;\n\t\t\tconst existingDistance = distances.get(traversalEdge.to);\n\t\t\tconst existingPathKey = pathKeys.get(traversalEdge.to);\n\t\t\tif (\n\t\t\t\texistingDistance === undefined ||\n\t\t\t\tcandidateDistance < existingDistance - FLOAT_EPSILON ||\n\t\t\t\t(Math.abs(candidateDistance - existingDistance) <= FLOAT_EPSILON &&\n\t\t\t\t\t(existingPathKey === undefined || candidatePathKey.localeCompare(existingPathKey) < 0))\n\t\t\t) {\n\t\t\t\tdistances.set(traversalEdge.to, candidateDistance);\n\t\t\t\tpathKeys.set(traversalEdge.to, candidatePathKey);\n\t\t\t\tpredecessors.set(traversalEdge.to, { nodeId: currentNodeId, edge: traversalEdge.edge });\n\t\t\t\tfrontier.add(traversalEdge.to);\n\t\t\t}\n\t\t}\n\t}\n\n\tconst sortedReachableNodeIds = [...distances.keys()].sort((a, b) => a.localeCompare(b));\n\tconst paths = new Map<string, readonly DijkstraPathStep[]>();\n\tconst nodePaths = new Map<string, readonly string[]>();\n\tfor (const nodeId of sortedReachableNodeIds) {\n\t\tconst builtPath = buildPath(nodeId, predecessors);\n\t\tpaths.set(nodeId, builtPath.edgeSteps);\n\t\tnodePaths.set(nodeId, builtPath.nodeIds);\n\t}\n\n\treturn {\n\t\tdistances,\n\t\tpredecessors,\n\t\tpaths,\n\t\tnodePaths,\n\t\tsettledNodeIds,\n\t};\n};\n\nexport const detectDependencyCycles = (input: DependencyCycleInput): string[][] => {\n\tconst nodeIds = [...collectNodeIds(input.nodes, input.edges)].sort((a, b) => a.localeCompare(b));\n\tconst adjacency = buildDependencyAdjacency(input.edges, \"forward\");\n\tconst selfLoops = new Set(\n\t\tnormalizeEdges(input.edges)\n\t\t\t.filter((edge) => isDependencyEdge(edge) && edge.source === edge.target)\n\t\t\t.map((edge) => edge.source),\n\t);\n\tconst indexes = new Map<string, number>();\n\tconst lowLinks = new Map<string, number>();\n\tconst stack: string[] = [];\n\tconst stacked = new Set<string>();\n\tconst cycles: string[][] = [];\n\tlet nextIndex = 0;\n\n\tconst visit = (nodeId: string): void => {\n\t\tindexes.set(nodeId, nextIndex);\n\t\tlowLinks.set(nodeId, nextIndex);\n\t\tnextIndex += 1;\n\t\tstack.push(nodeId);\n\t\tstacked.add(nodeId);\n\n\t\tfor (const nextNodeId of adjacency.get(nodeId) ?? []) {\n\t\t\tif (!indexes.has(nextNodeId)) {\n\t\t\t\tvisit(nextNodeId);\n\t\t\t\tlowLinks.set(nodeId, Math.min(lowLinks.get(nodeId) ?? 0, lowLinks.get(nextNodeId) ?? 0));\n\t\t\t} else if (stacked.has(nextNodeId)) {\n\t\t\t\tlowLinks.set(nodeId, Math.min(lowLinks.get(nodeId) ?? 0, indexes.get(nextNodeId) ?? 0));\n\t\t\t}\n\t\t}\n\n\t\tif (lowLinks.get(nodeId) !== indexes.get(nodeId)) return;\n\n\t\tconst component: string[] = [];\n\t\twhile (stack.length > 0) {\n\t\t\tconst member = stack.pop();\n\t\t\tif (member === undefined) break;\n\t\t\tstacked.delete(member);\n\t\t\tcomponent.push(member);\n\t\t\tif (member === nodeId) break;\n\t\t}\n\n\t\tif (component.length > 1 || selfLoops.has(nodeId)) cycles.push(component.sort((a, b) => a.localeCompare(b)));\n\t};\n\n\tfor (const nodeId of nodeIds) {\n\t\tif (!indexes.has(nodeId)) visit(nodeId);\n\t}\n\n\treturn cycles.sort(compareStringLists);\n};\n\nexport const propagateImpact = (input: ImpactPropagationInput): ImpactPropagationResult => {\n\tconst traversalEdges = buildTraversalEdges(input.edges, \"reverse-impact\");\n\tconst adjacency = buildTraversalAdjacency(traversalEdges);\n\tconst threshold = clamp01(input.threshold ?? 0);\n\tconst decay = input.decay === undefined ? 1 : clamp01(input.decay);\n\tconst scores = new Map<string, number>();\n\tconst frontier = new Set<string>();\n\tconst settled = new Set<string>();\n\tconst changedNodeIds = uniqueSorted(input.changedNodeIds.map(normalizeId).filter((nodeId) => nodeId.length > 0));\n\n\tfor (const nodeId of changedNodeIds) {\n\t\tscores.set(nodeId, 1);\n\t\tfrontier.add(nodeId);\n\t}\n\n\twhile (frontier.size > 0) {\n\t\tconst nodeId = pickHighestScoreNode(frontier, scores);\n\t\tif (nodeId === undefined) break;\n\n\t\tfrontier.delete(nodeId);\n\t\tsettled.add(nodeId);\n\t\tconst currentScore = scores.get(nodeId) ?? 0;\n\n\t\tfor (const traversalEdge of adjacency.get(nodeId) ?? []) {\n\t\t\tconst propagatedScore = currentScore * clamp01(traversalEdge.edge.reliability ?? 1) * decay;\n\t\t\tif (propagatedScore <= FLOAT_EPSILON || propagatedScore < threshold - FLOAT_EPSILON) continue;\n\n\t\t\tconst existingScore = scores.get(traversalEdge.to);\n\t\t\tif (existingScore === undefined || propagatedScore > existingScore + FLOAT_EPSILON) {\n\t\t\t\tscores.set(traversalEdge.to, propagatedScore);\n\t\t\t\tif (!settled.has(traversalEdge.to)) frontier.add(traversalEdge.to);\n\t\t\t}\n\t\t}\n\t}\n\n\tconst impacted = [...scores.entries()]\n\t\t.filter(([, score]) => score >= threshold - FLOAT_EPSILON)\n\t\t.map(([nodeId, score]) => ({ nodeId, score }))\n\t\t.sort(compareImpactHits);\n\n\treturn { scores, impacted };\n};\n\nexport const selectTestsByGreedyWeightedSetCover = (\n\tinput: GreedyWeightedSetCoverInput,\n): GreedyWeightedSetCoverResult => {\n\tconst targetWeights = normalizeTargetWeights(input.targets);\n\tconst remainingTargetIds = new Set(targetWeights.keys());\n\tconst selectedTests: TestCoverageCandidate[] = [];\n\tconst selectedTestIds = new Set<string>();\n\tlet totalCost = 0;\n\tlet totalWeightCovered = 0;\n\n\twhile (remainingTargetIds.size > 0) {\n\t\tlet bestCandidate: TestSelectionCandidate | undefined;\n\t\tfor (const test of [...input.tests].sort((a, b) => a.id.localeCompare(b.id))) {\n\t\t\tif (selectedTestIds.has(test.id)) continue;\n\n\t\t\tconst candidate = scoreTestSelectionCandidate(test, remainingTargetIds, targetWeights);\n\t\t\tif (candidate.gain <= FLOAT_EPSILON) continue;\n\t\t\tif (bestCandidate === undefined || compareTestSelectionCandidates(candidate, bestCandidate) < 0) {\n\t\t\t\tbestCandidate = candidate;\n\t\t\t}\n\t\t}\n\n\t\tif (bestCandidate === undefined) break;\n\n\t\tselectedTests.push(bestCandidate.test);\n\t\tselectedTestIds.add(bestCandidate.test.id);\n\t\ttotalCost += bestCandidate.effectiveCost;\n\t\ttotalWeightCovered += bestCandidate.gain;\n\t\tfor (const targetId of bestCandidate.coveredTargetIds) {\n\t\t\tremainingTargetIds.delete(targetId);\n\t\t}\n\t}\n\n\tconst uncoveredTargetIds = [...remainingTargetIds].sort((a, b) => a.localeCompare(b));\n\tconst coveredTargetIds = [...targetWeights.keys()]\n\t\t.filter((targetId) => !remainingTargetIds.has(targetId))\n\t\t.sort((a, b) => a.localeCompare(b));\n\n\treturn {\n\t\tselectedTests,\n\t\tcoveredTargetIds,\n\t\tuncoveredTargetIds,\n\t\ttotalCost,\n\t\ttotalWeightCovered,\n\t};\n};\n\nexport const scoreGraphHotspots = (input: HotspotScoringInput): HotspotScore[] => {\n\tconst nodeIds = collectNodeIds(input.nodes, input.edges);\n\tconst nodeById = new Map(input.nodes.map((node) => [normalizeId(node.id), node]));\n\tconst dependencyEdges = normalizeEdges(input.edges).filter(isDependencyEdge);\n\tconst fanInSources = new Map<string, Set<string>>();\n\tconst fanOutTargets = new Map<string, Set<string>>();\n\n\tfor (const edge of dependencyEdges) {\n\t\taddSetValue(fanInSources, edge.target, edge.source);\n\t\taddSetValue(fanOutTargets, edge.source, edge.target);\n\t}\n\n\tconst reverseReachableCounts = calculateReverseReachableCounts([...nodeIds], dependencyEdges);\n\tconst maxFanIn = maxMapSetSize(fanInSources);\n\tconst maxFanOut = maxMapSetSize(fanOutTargets);\n\tconst maxReverseReachable = Math.max(1, ...reverseReachableCounts.values());\n\tconst weights = { ...DEFAULT_HOTSPOT_WEIGHTS, ...input.weights };\n\n\treturn [...nodeIds]\n\t\t.map((nodeId) => {\n\t\t\tconst node = nodeById.get(nodeId);\n\t\t\tconst breakdown = {\n\t\t\t\tchangeFrequency: clamp01(node?.changeFrequency ?? 0),\n\t\t\t\tfailureRate: clamp01(node?.failureRate ?? 0),\n\t\t\t\tcomplexity: clamp01(node?.complexity ?? 0),\n\t\t\t\tfanIn: normalizeRatio(fanInSources.get(nodeId)?.size ?? 0, maxFanIn),\n\t\t\t\tfanOut: normalizeRatio(fanOutTargets.get(nodeId)?.size ?? 0, maxFanOut),\n\t\t\t\treverseImpact: normalizeRatio(reverseReachableCounts.get(nodeId) ?? 0, maxReverseReachable),\n\t\t\t\tcentrality: clamp01(node?.centrality ?? 0),\n\t\t\t\treliabilityRisk: 1 - clamp01(node?.reliability ?? 1),\n\t\t\t};\n\t\t\treturn {\n\t\t\t\tnodeId,\n\t\t\t\tscore: calculateHotspotScore(breakdown, weights),\n\t\t\t\tbreakdown,\n\t\t\t};\n\t\t})\n\t\t.sort(compareHotspotScores);\n};\n\nexport const multiSourceDijkstra = runMultiSourceDijkstra;\nexport const findDependencyCycles = detectDependencyCycles;\nexport const propagateReverseImpact = propagateImpact;\nexport const selectTestsByWeightedSetCover = selectTestsByGreedyWeightedSetCover;\nexport const scoreHotspots = scoreGraphHotspots;\n\nconst buildPath = (\n\tnodeId: string,\n\tpredecessors: ReadonlyMap<string, DijkstraPredecessor>,\n): { readonly edgeSteps: readonly DijkstraPathStep[]; readonly nodeIds: readonly string[] } => {\n\tconst reversedSteps: DijkstraPathStep[] = [];\n\tconst reversedNodeIds = [nodeId];\n\tlet currentNodeId = nodeId;\n\tconst seen = new Set<string>();\n\n\twhile (!seen.has(currentNodeId)) {\n\t\tseen.add(currentNodeId);\n\t\tconst predecessor = predecessors.get(currentNodeId);\n\t\tif (predecessor === undefined) break;\n\t\treversedSteps.push({ nodeId: currentNodeId, edge: predecessor.edge });\n\t\tcurrentNodeId = predecessor.nodeId;\n\t\treversedNodeIds.push(currentNodeId);\n\t}\n\n\treturn {\n\t\tedgeSteps: reversedSteps.reverse(),\n\t\tnodeIds: reversedNodeIds.reverse(),\n\t};\n};\n\nconst buildTraversalEdges = (edges: readonly ContextGraphEdge[], mode: ContextGraphTraversalMode): TraversalEdge[] => {\n\tconst traversalEdges: TraversalEdge[] = [];\n\tfor (const edge of normalizeEdges(edges)) {\n\t\tif (mode === \"dependency\" && isDependencyEdge(edge)) {\n\t\t\ttraversalEdges.push(makeTraversalEdge(edge, edge.source, edge.target, \"forward\"));\n\t\t} else if (mode === \"reverse-impact\" && isDependencyEdge(edge)) {\n\t\t\ttraversalEdges.push(makeTraversalEdge(edge, edge.target, edge.source, \"reverse\"));\n\t\t} else if (mode === \"neighbors\") {\n\t\t\ttraversalEdges.push(makeTraversalEdge(edge, edge.source, edge.target, \"forward\"));\n\t\t\tif (edge.source !== edge.target)\n\t\t\t\ttraversalEdges.push(makeTraversalEdge(edge, edge.target, edge.source, \"reverse\"));\n\t\t} else if (mode === \"tests\" && isTestEdge(edge)) {\n\t\t\ttraversalEdges.push(makeTraversalEdge(edge, edge.source, edge.target, \"forward\"));\n\t\t\tif (edge.source !== edge.target)\n\t\t\t\ttraversalEdges.push(makeTraversalEdge(edge, edge.target, edge.source, \"reverse\"));\n\t\t}\n\t}\n\treturn traversalEdges.sort(compareTraversalEdges);\n};\n\nconst makeTraversalEdge = (\n\tedge: NormalizedContextGraphEdge,\n\tfrom: string,\n\tto: string,\n\tdirection: \"forward\" | \"reverse\",\n): TraversalEdge => ({\n\tfrom,\n\tto,\n\tedge,\n\tcost: calculateTraversalEdgeCost(edge),\n\tdirection,\n});\n\nconst calculateTraversalEdgeCost = (edge: ContextGraphEdge): number => {\n\tconst baseCost = normalizePositiveNumber(edge.weight, 1);\n\treturn baseCost * reliabilityToTraversalCost(edge.reliability ?? 1);\n};\n\nconst buildTraversalAdjacency = (\n\ttraversalEdges: readonly TraversalEdge[],\n): ReadonlyMap<string, readonly TraversalEdge[]> => {\n\tconst adjacency = new Map<string, TraversalEdge[]>();\n\tfor (const traversalEdge of traversalEdges) {\n\t\tconst existing = adjacency.get(traversalEdge.from) ?? [];\n\t\tadjacency.set(traversalEdge.from, [...existing, traversalEdge].sort(compareTraversalEdges));\n\t}\n\treturn adjacency;\n};\n\nconst buildDependencyAdjacency = (\n\tedges: readonly ContextGraphEdge[],\n\tdirection: \"forward\" | \"reverse\",\n): ReadonlyMap<string, readonly string[]> => {\n\tconst adjacency = new Map<string, Set<string>>();\n\tfor (const edge of normalizeEdges(edges).filter(isDependencyEdge)) {\n\t\tconst from = direction === \"forward\" ? edge.source : edge.target;\n\t\tconst to = direction === \"forward\" ? edge.target : edge.source;\n\t\taddSetValue(adjacency, from, to);\n\t}\n\treturn new Map(\n\t\t[...adjacency.entries()].map(([nodeId, neighbors]) => [\n\t\t\tnodeId,\n\t\t\t[...neighbors].sort((a, b) => a.localeCompare(b)),\n\t\t]),\n\t);\n};\n\nconst normalizeEdges = (edges: readonly ContextGraphEdge[]): NormalizedContextGraphEdge[] =>\n\tedges.flatMap((edge, index) => {\n\t\tconst source = normalizeId(edge.source);\n\t\tconst target = normalizeId(edge.target);\n\t\tif (source.length === 0 || target.length === 0) return [];\n\t\tconst kind = (edge.kind ?? \"related\").trim() || \"related\";\n\t\tconst explicitId = edge.id?.trim();\n\t\tconst id = explicitId && explicitId.length > 0 ? explicitId : `${kind}:${source}->${target}:${index}`;\n\t\treturn [{ ...edge, id, source, target, kind }];\n\t});\n\nconst collectNodeIds = (nodes: readonly ContextGraphNode[], edges: readonly ContextGraphEdge[]): Set<string> => {\n\tconst nodeIds = new Set<string>();\n\tfor (const node of nodes) {\n\t\tconst nodeId = normalizeId(node.id);\n\t\tif (nodeId.length > 0) nodeIds.add(nodeId);\n\t}\n\tfor (const edge of normalizeEdges(edges)) {\n\t\tnodeIds.add(edge.source);\n\t\tnodeIds.add(edge.target);\n\t}\n\treturn nodeIds;\n};\n\nconst pickLowestCostNode = (\n\tfrontier: ReadonlySet<string>,\n\tdistances: ReadonlyMap<string, number>,\n\tpathKeys: ReadonlyMap<string, string>,\n): string | undefined =>\n\t[...frontier].sort((a, b) => {\n\t\tconst distanceDelta =\n\t\t\t(distances.get(a) ?? Number.POSITIVE_INFINITY) - (distances.get(b) ?? Number.POSITIVE_INFINITY);\n\t\tif (Math.abs(distanceDelta) > FLOAT_EPSILON) return distanceDelta;\n\t\treturn (pathKeys.get(a) ?? a).localeCompare(pathKeys.get(b) ?? b) || a.localeCompare(b);\n\t})[0];\n\nconst pickHighestScoreNode = (frontier: ReadonlySet<string>, scores: ReadonlyMap<string, number>): string | undefined =>\n\t[...frontier].sort((a, b) => (scores.get(b) ?? 0) - (scores.get(a) ?? 0) || a.localeCompare(b))[0];\n\nconst scoreTestSelectionCandidate = (\n\ttest: TestCoverageCandidate,\n\tremainingTargetIds: ReadonlySet<string>,\n\ttargetWeights: ReadonlyMap<string, number>,\n): TestSelectionCandidate => {\n\tconst coverage = normalizeCoverage(test.covers);\n\tconst coveredTargetIds = [...remainingTargetIds]\n\t\t.filter((targetId) => (coverage.get(targetId) ?? 0) > 0)\n\t\t.sort((a, b) => a.localeCompare(b));\n\tconst gain = coveredTargetIds.reduce(\n\t\t(sum, targetId) => sum + (targetWeights.get(targetId) ?? 0) * (coverage.get(targetId) ?? 0),\n\t\t0,\n\t);\n\tconst effectiveCost = normalizePositiveNumber(test.cost, 1) * reliabilityToTraversalCost(test.reliability ?? 1);\n\treturn {\n\t\ttest,\n\t\tgain,\n\t\tratio: gain / effectiveCost,\n\t\teffectiveCost,\n\t\tcoveredTargetIds,\n\t};\n};\n\nconst normalizeCoverage = (covers: readonly TestCoverageInput[]): ReadonlyMap<string, number> => {\n\tconst coverage = new Map<string, number>();\n\tfor (const cover of covers) {\n\t\tconst targetId = typeof cover === \"string\" ? normalizeId(cover) : normalizeId(cover.targetId);\n\t\tif (targetId.length === 0) continue;\n\t\tconst weight = typeof cover === \"string\" ? 1 : normalizePositiveNumber(cover.weight, 1);\n\t\tcoverage.set(targetId, Math.max(coverage.get(targetId) ?? 0, weight));\n\t}\n\treturn coverage;\n};\n\nconst normalizeTargetWeights = (targets: readonly SetCoverTarget[]): ReadonlyMap<string, number> => {\n\tconst targetWeights = new Map<string, number>();\n\tfor (const target of targets) {\n\t\tconst targetId = normalizeId(target.id);\n\t\tif (targetId.length === 0) continue;\n\t\ttargetWeights.set(\n\t\t\ttargetId,\n\t\t\tMath.max(targetWeights.get(targetId) ?? 0, normalizePositiveNumber(target.weight, 1)),\n\t\t);\n\t}\n\treturn new Map([...targetWeights.entries()].sort(([a], [b]) => a.localeCompare(b)));\n};\n\nconst calculateReverseReachableCounts = (\n\tnodeIds: readonly string[],\n\tdependencyEdges: readonly NormalizedContextGraphEdge[],\n): ReadonlyMap<string, number> => {\n\tconst reverseAdjacency = buildDependencyAdjacency(dependencyEdges, \"reverse\");\n\tconst counts = new Map<string, number>();\n\tfor (const nodeId of nodeIds) {\n\t\tconst visited = new Set<string>();\n\t\tconst queue = [...(reverseAdjacency.get(nodeId) ?? [])];\n\t\twhile (queue.length > 0) {\n\t\t\tconst current = queue.shift();\n\t\t\tif (current === undefined || current === nodeId || visited.has(current)) continue;\n\t\t\tvisited.add(current);\n\t\t\tqueue.push(...(reverseAdjacency.get(current) ?? []));\n\t\t}\n\t\tcounts.set(nodeId, visited.size);\n\t}\n\treturn counts;\n};\n\nconst calculateHotspotScore = (breakdown: HotspotScoreBreakdown, weights: HotspotScoreWeights): number =>\n\tclamp01(\n\t\tbreakdown.changeFrequency * weights.changeFrequency +\n\t\t\tbreakdown.failureRate * weights.failureRate +\n\t\t\tbreakdown.complexity * weights.complexity +\n\t\t\tbreakdown.fanIn * weights.fanIn +\n\t\t\tbreakdown.fanOut * weights.fanOut +\n\t\t\tbreakdown.reverseImpact * weights.reverseImpact +\n\t\t\tbreakdown.centrality * weights.centrality +\n\t\t\tbreakdown.reliabilityRisk * weights.reliabilityRisk,\n\t);\n\nconst compareTraversalEdges = (a: TraversalEdge, b: TraversalEdge): number =>\n\ta.from.localeCompare(b.from) ||\n\ta.to.localeCompare(b.to) ||\n\ta.cost - b.cost ||\n\ta.edge.id.localeCompare(b.edge.id) ||\n\ta.direction.localeCompare(b.direction);\n\nconst compareImpactHits = (a: ImpactPropagationHit, b: ImpactPropagationHit): number =>\n\tb.score - a.score || a.nodeId.localeCompare(b.nodeId);\n\nconst compareHotspotScores = (a: HotspotScore, b: HotspotScore): number =>\n\tb.score - a.score || a.nodeId.localeCompare(b.nodeId);\n\nconst compareStringLists = (a: readonly string[], b: readonly string[]): number =>\n\ta[0]?.localeCompare(b[0] ?? \"\") || a.length - b.length || a.join(\"\\0\").localeCompare(b.join(\"\\0\"));\n\nconst compareTestSelectionCandidates = (a: TestSelectionCandidate, b: TestSelectionCandidate): number =>\n\tb.ratio - a.ratio || b.gain - a.gain || a.effectiveCost - b.effectiveCost || a.test.id.localeCompare(b.test.id);\n\nconst isDependencyEdge = (edge: ContextGraphEdge): boolean => edge.kind === \"dependency\";\n\nconst isTestEdge = (edge: ContextGraphEdge): boolean =>\n\tedge.kind === \"test\" || edge.kind === \"tests\" || edge.kind === \"coverage\";\n\nconst addSetValue = <TKey, TValue>(map: Map<TKey, Set<TValue>>, key: TKey, value: TValue): void => {\n\tconst existing = map.get(key);\n\tif (existing === undefined) {\n\t\tmap.set(key, new Set([value]));\n\t\treturn;\n\t}\n\texisting.add(value);\n};\n\nconst maxMapSetSize = <TKey, TValue>(map: ReadonlyMap<TKey, ReadonlySet<TValue>>): number =>\n\tMath.max(1, ...[...map.values()].map((items) => items.size));\n\nconst normalizeRatio = (value: number, maxValue: number): number => {\n\tif (!Number.isFinite(value) || !Number.isFinite(maxValue) || maxValue <= 0) return 0;\n\treturn clamp01(value / maxValue);\n};\n\nconst normalizePositiveNumber = (value: number | undefined, fallback: number): number =>\n\tvalue !== undefined && Number.isFinite(value) && value > 0 ? value : fallback;\n\nconst normalizeId = (id: string): string => id.trim();\n\nconst uniqueSorted = (values: readonly string[]): string[] => [...new Set(values)].sort((a, b) => a.localeCompare(b));\n\nconst clamp01 = (value: number): number => {\n\tif (!Number.isFinite(value) || value <= 0) return 0;\n\tif (value >= 1) return 1;\n\treturn value;\n};\n"]}

package/dist/core/context-graph-reasoning.js

@@ -0,0 +1,442 @@
+const MIN_RELIABILITY = 0.001;
+const FLOAT_EPSILON = 1e-12;
+const DEFAULT_HOTSPOT_WEIGHTS = {
+    changeFrequency: 0.18,
+    failureRate: 0.22,
+    complexity: 0.15,
+    fanIn: 0.15,
+    fanOut: 0.05,
+    reverseImpact: 0.15,
+    centrality: 0.05,
+    reliabilityRisk: 0.05,
+};
+export const reliabilityToTraversalCost = (reliability = 1) => {
+    const normalizedReliability = Math.max(MIN_RELIABILITY, clamp01(reliability));
+    return 1 / normalizedReliability;
+};
+export const runMultiSourceDijkstra = (input) => {
+    const nodeIds = collectNodeIds(input.nodes, input.edges);
+    const traversalEdges = buildTraversalEdges(input.edges, input.mode);
+    const adjacency = buildTraversalAdjacency(traversalEdges);
+    const sources = uniqueSorted(input.sources.map(normalizeId).filter((source) => source.length > 0));
+    const distances = new Map();
+    const predecessors = new Map();
+    const pathKeys = new Map();
+    const frontier = new Set();
+    const settledNodeIds = [];
+    const maxCost = normalizePositiveNumber(input.maxCost, Number.POSITIVE_INFINITY);
+    for (const source of sources) {
+        nodeIds.add(source);
+        distances.set(source, 0);
+        pathKeys.set(source, source);
+        frontier.add(source);
+    }
+    while (frontier.size > 0) {
+        const currentNodeId = pickLowestCostNode(frontier, distances, pathKeys);
+        if (currentNodeId === undefined)
+            break;
+        frontier.delete(currentNodeId);
+        settledNodeIds.push(currentNodeId);
+        const currentDistance = distances.get(currentNodeId) ?? Number.POSITIVE_INFINITY;
+        const currentPathKey = pathKeys.get(currentNodeId) ?? currentNodeId;
+        for (const traversalEdge of adjacency.get(currentNodeId) ?? []) {
+            const candidateDistance = currentDistance + traversalEdge.cost;
+            if (candidateDistance > maxCost + FLOAT_EPSILON)
+                continue;
+            const candidatePathKey = `${currentPathKey}\0${traversalEdge.to}\0${traversalEdge.edge.id}`;
+            const existingDistance = distances.get(traversalEdge.to);
+            const existingPathKey = pathKeys.get(traversalEdge.to);
+            if (existingDistance === undefined ||
+                candidateDistance < existingDistance - FLOAT_EPSILON ||
+                (Math.abs(candidateDistance - existingDistance) <= FLOAT_EPSILON &&
+                    (existingPathKey === undefined || candidatePathKey.localeCompare(existingPathKey) < 0))) {
+                distances.set(traversalEdge.to, candidateDistance);
+                pathKeys.set(traversalEdge.to, candidatePathKey);
+                predecessors.set(traversalEdge.to, { nodeId: currentNodeId, edge: traversalEdge.edge });
+                frontier.add(traversalEdge.to);
+            }
+        }
+    }
+    const sortedReachableNodeIds = [...distances.keys()].sort((a, b) => a.localeCompare(b));
+    const paths = new Map();
+    const nodePaths = new Map();
+    for (const nodeId of sortedReachableNodeIds) {
+        const builtPath = buildPath(nodeId, predecessors);
+        paths.set(nodeId, builtPath.edgeSteps);
+        nodePaths.set(nodeId, builtPath.nodeIds);
+    }
+    return {
+        distances,
+        predecessors,
+        paths,
+        nodePaths,
+        settledNodeIds,
+    };
+};
+export const detectDependencyCycles = (input) => {
+    const nodeIds = [...collectNodeIds(input.nodes, input.edges)].sort((a, b) => a.localeCompare(b));
+    const adjacency = buildDependencyAdjacency(input.edges, "forward");
+    const selfLoops = new Set(normalizeEdges(input.edges)
+        .filter((edge) => isDependencyEdge(edge) && edge.source === edge.target)
+        .map((edge) => edge.source));
+    const indexes = new Map();
+    const lowLinks = new Map();
+    const stack = [];
+    const stacked = new Set();
+    const cycles = [];
+    let nextIndex = 0;
+    const visit = (nodeId) => {
+        indexes.set(nodeId, nextIndex);
+        lowLinks.set(nodeId, nextIndex);
+        nextIndex += 1;
+        stack.push(nodeId);
+        stacked.add(nodeId);
+        for (const nextNodeId of adjacency.get(nodeId) ?? []) {
+            if (!indexes.has(nextNodeId)) {
+                visit(nextNodeId);
+                lowLinks.set(nodeId, Math.min(lowLinks.get(nodeId) ?? 0, lowLinks.get(nextNodeId) ?? 0));
+            }
+            else if (stacked.has(nextNodeId)) {
+                lowLinks.set(nodeId, Math.min(lowLinks.get(nodeId) ?? 0, indexes.get(nextNodeId) ?? 0));
+            }
+        }
+        if (lowLinks.get(nodeId) !== indexes.get(nodeId))
+            return;
+        const component = [];
+        while (stack.length > 0) {
+            const member = stack.pop();
+            if (member === undefined)
+                break;
+            stacked.delete(member);
+            component.push(member);
+            if (member === nodeId)
+                break;
+        }
+        if (component.length > 1 || selfLoops.has(nodeId))
+            cycles.push(component.sort((a, b) => a.localeCompare(b)));
+    };
+    for (const nodeId of nodeIds) {
+        if (!indexes.has(nodeId))
+            visit(nodeId);
+    }
+    return cycles.sort(compareStringLists);
+};
+export const propagateImpact = (input) => {
+    const traversalEdges = buildTraversalEdges(input.edges, "reverse-impact");
+    const adjacency = buildTraversalAdjacency(traversalEdges);
+    const threshold = clamp01(input.threshold ?? 0);
+    const decay = input.decay === undefined ? 1 : clamp01(input.decay);
+    const scores = new Map();
+    const frontier = new Set();
+    const settled = new Set();
+    const changedNodeIds = uniqueSorted(input.changedNodeIds.map(normalizeId).filter((nodeId) => nodeId.length > 0));
+    for (const nodeId of changedNodeIds) {
+        scores.set(nodeId, 1);
+        frontier.add(nodeId);
+    }
+    while (frontier.size > 0) {
+        const nodeId = pickHighestScoreNode(frontier, scores);
+        if (nodeId === undefined)
+            break;
+        frontier.delete(nodeId);
+        settled.add(nodeId);
+        const currentScore = scores.get(nodeId) ?? 0;
+        for (const traversalEdge of adjacency.get(nodeId) ?? []) {
+            const propagatedScore = currentScore * clamp01(traversalEdge.edge.reliability ?? 1) * decay;
+            if (propagatedScore <= FLOAT_EPSILON || propagatedScore < threshold - FLOAT_EPSILON)
+                continue;
+            const existingScore = scores.get(traversalEdge.to);
+            if (existingScore === undefined || propagatedScore > existingScore + FLOAT_EPSILON) {
+                scores.set(traversalEdge.to, propagatedScore);
+                if (!settled.has(traversalEdge.to))
+                    frontier.add(traversalEdge.to);
+            }
+        }
+    }
+    const impacted = [...scores.entries()]
+        .filter(([, score]) => score >= threshold - FLOAT_EPSILON)
+        .map(([nodeId, score]) => ({ nodeId, score }))
+        .sort(compareImpactHits);
+    return { scores, impacted };
+};
+export const selectTestsByGreedyWeightedSetCover = (input) => {
+    const targetWeights = normalizeTargetWeights(input.targets);
+    const remainingTargetIds = new Set(targetWeights.keys());
+    const selectedTests = [];
+    const selectedTestIds = new Set();
+    let totalCost = 0;
+    let totalWeightCovered = 0;
+    while (remainingTargetIds.size > 0) {
+        let bestCandidate;
+        for (const test of [...input.tests].sort((a, b) => a.id.localeCompare(b.id))) {
+            if (selectedTestIds.has(test.id))
+                continue;
+            const candidate = scoreTestSelectionCandidate(test, remainingTargetIds, targetWeights);
+            if (candidate.gain <= FLOAT_EPSILON)
+                continue;
+            if (bestCandidate === undefined || compareTestSelectionCandidates(candidate, bestCandidate) < 0) {
+                bestCandidate = candidate;
+            }
+        }
+        if (bestCandidate === undefined)
+            break;
+        selectedTests.push(bestCandidate.test);
+        selectedTestIds.add(bestCandidate.test.id);
+        totalCost += bestCandidate.effectiveCost;
+        totalWeightCovered += bestCandidate.gain;
+        for (const targetId of bestCandidate.coveredTargetIds) {
+            remainingTargetIds.delete(targetId);
+        }
+    }
+    const uncoveredTargetIds = [...remainingTargetIds].sort((a, b) => a.localeCompare(b));
+    const coveredTargetIds = [...targetWeights.keys()]
+        .filter((targetId) => !remainingTargetIds.has(targetId))
+        .sort((a, b) => a.localeCompare(b));
+    return {
+        selectedTests,
+        coveredTargetIds,
+        uncoveredTargetIds,
+        totalCost,
+        totalWeightCovered,
+    };
+};
+export const scoreGraphHotspots = (input) => {
+    const nodeIds = collectNodeIds(input.nodes, input.edges);
+    const nodeById = new Map(input.nodes.map((node) => [normalizeId(node.id), node]));
+    const dependencyEdges = normalizeEdges(input.edges).filter(isDependencyEdge);
+    const fanInSources = new Map();
+    const fanOutTargets = new Map();
+    for (const edge of dependencyEdges) {
+        addSetValue(fanInSources, edge.target, edge.source);
+        addSetValue(fanOutTargets, edge.source, edge.target);
+    }
+    const reverseReachableCounts = calculateReverseReachableCounts([...nodeIds], dependencyEdges);
+    const maxFanIn = maxMapSetSize(fanInSources);
+    const maxFanOut = maxMapSetSize(fanOutTargets);
+    const maxReverseReachable = Math.max(1, ...reverseReachableCounts.values());
+    const weights = { ...DEFAULT_HOTSPOT_WEIGHTS, ...input.weights };
+    return [...nodeIds]
+        .map((nodeId) => {
+        const node = nodeById.get(nodeId);
+        const breakdown = {
+            changeFrequency: clamp01(node?.changeFrequency ?? 0),
+            failureRate: clamp01(node?.failureRate ?? 0),
+            complexity: clamp01(node?.complexity ?? 0),
+            fanIn: normalizeRatio(fanInSources.get(nodeId)?.size ?? 0, maxFanIn),
+            fanOut: normalizeRatio(fanOutTargets.get(nodeId)?.size ?? 0, maxFanOut),
+            reverseImpact: normalizeRatio(reverseReachableCounts.get(nodeId) ?? 0, maxReverseReachable),
+            centrality: clamp01(node?.centrality ?? 0),
+            reliabilityRisk: 1 - clamp01(node?.reliability ?? 1),
+        };
+        return {
+            nodeId,
+            score: calculateHotspotScore(breakdown, weights),
+            breakdown,
+        };
+    })
+        .sort(compareHotspotScores);
+};
+export const multiSourceDijkstra = runMultiSourceDijkstra;
+export const findDependencyCycles = detectDependencyCycles;
+export const propagateReverseImpact = propagateImpact;
+export const selectTestsByWeightedSetCover = selectTestsByGreedyWeightedSetCover;
+export const scoreHotspots = scoreGraphHotspots;
+const buildPath = (nodeId, predecessors) => {
+    const reversedSteps = [];
+    const reversedNodeIds = [nodeId];
+    let currentNodeId = nodeId;
+    const seen = new Set();
+    while (!seen.has(currentNodeId)) {
+        seen.add(currentNodeId);
+        const predecessor = predecessors.get(currentNodeId);
+        if (predecessor === undefined)
+            break;
+        reversedSteps.push({ nodeId: currentNodeId, edge: predecessor.edge });
+        currentNodeId = predecessor.nodeId;
+        reversedNodeIds.push(currentNodeId);
+    }
+    return {
+        edgeSteps: reversedSteps.reverse(),
+        nodeIds: reversedNodeIds.reverse(),
+    };
+};
+const buildTraversalEdges = (edges, mode) => {
+    const traversalEdges = [];
+    for (const edge of normalizeEdges(edges)) {
+        if (mode === "dependency" && isDependencyEdge(edge)) {
+            traversalEdges.push(makeTraversalEdge(edge, edge.source, edge.target, "forward"));
+        }
+        else if (mode === "reverse-impact" && isDependencyEdge(edge)) {
+            traversalEdges.push(makeTraversalEdge(edge, edge.target, edge.source, "reverse"));
+        }
+        else if (mode === "neighbors") {
+            traversalEdges.push(makeTraversalEdge(edge, edge.source, edge.target, "forward"));
+            if (edge.source !== edge.target)
+                traversalEdges.push(makeTraversalEdge(edge, edge.target, edge.source, "reverse"));
+        }
+        else if (mode === "tests" && isTestEdge(edge)) {
+            traversalEdges.push(makeTraversalEdge(edge, edge.source, edge.target, "forward"));
+            if (edge.source !== edge.target)
+                traversalEdges.push(makeTraversalEdge(edge, edge.target, edge.source, "reverse"));
+        }
+    }
+    return traversalEdges.sort(compareTraversalEdges);
+};
+const makeTraversalEdge = (edge, from, to, direction) => ({
+    from,
+    to,
+    edge,
+    cost: calculateTraversalEdgeCost(edge),
+    direction,
+});
+const calculateTraversalEdgeCost = (edge) => {
+    const baseCost = normalizePositiveNumber(edge.weight, 1);
+    return baseCost * reliabilityToTraversalCost(edge.reliability ?? 1);
+};
+const buildTraversalAdjacency = (traversalEdges) => {
+    const adjacency = new Map();
+    for (const traversalEdge of traversalEdges) {
+        const existing = adjacency.get(traversalEdge.from) ?? [];
+        adjacency.set(traversalEdge.from, [...existing, traversalEdge].sort(compareTraversalEdges));
+    }
+    return adjacency;
+};
+const buildDependencyAdjacency = (edges, direction) => {
+    const adjacency = new Map();
+    for (const edge of normalizeEdges(edges).filter(isDependencyEdge)) {
+        const from = direction === "forward" ? edge.source : edge.target;
+        const to = direction === "forward" ? edge.target : edge.source;
+        addSetValue(adjacency, from, to);
+    }
+    return new Map([...adjacency.entries()].map(([nodeId, neighbors]) => [
+        nodeId,
+        [...neighbors].sort((a, b) => a.localeCompare(b)),
+    ]));
+};
+const normalizeEdges = (edges) => edges.flatMap((edge, index) => {
+    const source = normalizeId(edge.source);
+    const target = normalizeId(edge.target);
+    if (source.length === 0 || target.length === 0)
+        return [];
+    const kind = (edge.kind ?? "related").trim() || "related";
+    const explicitId = edge.id?.trim();
+    const id = explicitId && explicitId.length > 0 ? explicitId : `${kind}:${source}->${target}:${index}`;
+    return [{ ...edge, id, source, target, kind }];
+});
+const collectNodeIds = (nodes, edges) => {
+    const nodeIds = new Set();
+    for (const node of nodes) {
+        const nodeId = normalizeId(node.id);
+        if (nodeId.length > 0)
+            nodeIds.add(nodeId);
+    }
+    for (const edge of normalizeEdges(edges)) {
+        nodeIds.add(edge.source);
+        nodeIds.add(edge.target);
+    }
+    return nodeIds;
+};
+const pickLowestCostNode = (frontier, distances, pathKeys) => [...frontier].sort((a, b) => {
+    const distanceDelta = (distances.get(a) ?? Number.POSITIVE_INFINITY) - (distances.get(b) ?? Number.POSITIVE_INFINITY);
+    if (Math.abs(distanceDelta) > FLOAT_EPSILON)
+        return distanceDelta;
+    return (pathKeys.get(a) ?? a).localeCompare(pathKeys.get(b) ?? b) || a.localeCompare(b);
+})[0];
+const pickHighestScoreNode = (frontier, scores) => [...frontier].sort((a, b) => (scores.get(b) ?? 0) - (scores.get(a) ?? 0) || a.localeCompare(b))[0];
+const scoreTestSelectionCandidate = (test, remainingTargetIds, targetWeights) => {
+    const coverage = normalizeCoverage(test.covers);
+    const coveredTargetIds = [...remainingTargetIds]
+        .filter((targetId) => (coverage.get(targetId) ?? 0) > 0)
+        .sort((a, b) => a.localeCompare(b));
+    const gain = coveredTargetIds.reduce((sum, targetId) => sum + (targetWeights.get(targetId) ?? 0) * (coverage.get(targetId) ?? 0), 0);
+    const effectiveCost = normalizePositiveNumber(test.cost, 1) * reliabilityToTraversalCost(test.reliability ?? 1);
+    return {
+        test,
+        gain,
+        ratio: gain / effectiveCost,
+        effectiveCost,
+        coveredTargetIds,
+    };
+};
+const normalizeCoverage = (covers) => {
+    const coverage = new Map();
+    for (const cover of covers) {
+        const targetId = typeof cover === "string" ? normalizeId(cover) : normalizeId(cover.targetId);
+        if (targetId.length === 0)
+            continue;
+        const weight = typeof cover === "string" ? 1 : normalizePositiveNumber(cover.weight, 1);
+        coverage.set(targetId, Math.max(coverage.get(targetId) ?? 0, weight));
+    }
+    return coverage;
+};
+const normalizeTargetWeights = (targets) => {
+    const targetWeights = new Map();
+    for (const target of targets) {
+        const targetId = normalizeId(target.id);
+        if (targetId.length === 0)
+            continue;
+        targetWeights.set(targetId, Math.max(targetWeights.get(targetId) ?? 0, normalizePositiveNumber(target.weight, 1)));
+    }
+    return new Map([...targetWeights.entries()].sort(([a], [b]) => a.localeCompare(b)));
+};
+const calculateReverseReachableCounts = (nodeIds, dependencyEdges) => {
+    const reverseAdjacency = buildDependencyAdjacency(dependencyEdges, "reverse");
+    const counts = new Map();
+    for (const nodeId of nodeIds) {
+        const visited = new Set();
+        const queue = [...(reverseAdjacency.get(nodeId) ?? [])];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === undefined || current === nodeId || visited.has(current))
+                continue;
+            visited.add(current);
+            queue.push(...(reverseAdjacency.get(current) ?? []));
+        }
+        counts.set(nodeId, visited.size);
+    }
+    return counts;
+};
+const calculateHotspotScore = (breakdown, weights) => clamp01(breakdown.changeFrequency * weights.changeFrequency +
+    breakdown.failureRate * weights.failureRate +
+    breakdown.complexity * weights.complexity +
+    breakdown.fanIn * weights.fanIn +
+    breakdown.fanOut * weights.fanOut +
+    breakdown.reverseImpact * weights.reverseImpact +
+    breakdown.centrality * weights.centrality +
+    breakdown.reliabilityRisk * weights.reliabilityRisk);
+const compareTraversalEdges = (a, b) => a.from.localeCompare(b.from) ||
+    a.to.localeCompare(b.to) ||
+    a.cost - b.cost ||
+    a.edge.id.localeCompare(b.edge.id) ||
+    a.direction.localeCompare(b.direction);
+const compareImpactHits = (a, b) => b.score - a.score || a.nodeId.localeCompare(b.nodeId);
+const compareHotspotScores = (a, b) => b.score - a.score || a.nodeId.localeCompare(b.nodeId);
+const compareStringLists = (a, b) => a[0]?.localeCompare(b[0] ?? "") || a.length - b.length || a.join("\0").localeCompare(b.join("\0"));
+const compareTestSelectionCandidates = (a, b) => b.ratio - a.ratio || b.gain - a.gain || a.effectiveCost - b.effectiveCost || a.test.id.localeCompare(b.test.id);
+const isDependencyEdge = (edge) => edge.kind === "dependency";
+const isTestEdge = (edge) => edge.kind === "test" || edge.kind === "tests" || edge.kind === "coverage";
+const addSetValue = (map, key, value) => {
+    const existing = map.get(key);
+    if (existing === undefined) {
+        map.set(key, new Set([value]));
+        return;
+    }
+    existing.add(value);
+};
+const maxMapSetSize = (map) => Math.max(1, ...[...map.values()].map((items) => items.size));
+const normalizeRatio = (value, maxValue) => {
+    if (!Number.isFinite(value) || !Number.isFinite(maxValue) || maxValue <= 0)
+        return 0;
+    return clamp01(value / maxValue);
+};
+const normalizePositiveNumber = (value, fallback) => value !== undefined && Number.isFinite(value) && value > 0 ? value : fallback;
+const normalizeId = (id) => id.trim();
+const uniqueSorted = (values) => [...new Set(values)].sort((a, b) => a.localeCompare(b));
+const clamp01 = (value) => {
+    if (!Number.isFinite(value) || value <= 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value;
+};
+//# sourceMappingURL=context-graph-reasoning.js.map