open-multi-agent-kit 0.80.7 → 0.80.8

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

@@ -1,130 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,442 +0,0 @@
-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