fix(validation): fix import paths and module resolution after reorganization

- Fix representativeness test fixtures imports (use ./fixtures/ relative path)
- Update test-graph-expander.ts to use correct relative paths for Graph/Neighbor
- Fix common/baselines and common/representativeness-helpers import paths
- Add vite-tsconfig-paths plugin for better TypeScript path resolution
- Configure resolve.extensions in vitest to include .ts files
- Change tsconfig moduleResolution from "bundler" to "node"

All 32 test files now passing with 67 tests total.

Author: Mearman

package.json

@@ -89,6 +89,7 @@
     "typescript-eslint": "^8.53.0",
     "vite": "7.3.1",
     "vite-plugin-dts": "^4.5.4",
+    "vite-tsconfig-paths": "^6.0.4",
     "vitest": "4.0.17"
   },
   "dependencies": {

pnpm-lock.yaml

@@ -0,0 +1,161 @@
+/**
+ * Shared test infrastructure for representativeness tests
+ */
+
+import { Graph } from "../../../../../../../../../../../algorithms/graph/graph";
+import type { Neighbor } from "../../../../../../../../../../../interfaces/graph-expander";
+
+export interface TestNode {
+	id: string;
+	type: string;
+	[key: string]: unknown;
+}
+
+export interface TestEdge {
+	id: string;
+	source: string;
+	target: string;
+	type: string;
+	[key: string]: unknown;
+}
+
+/**
+ * Adapter to use Graph class with expansion algorithms
+ */
+export class GraphExpanderAdapter {
+	private adjacency = new Map<string, Neighbor[]>();
+	private degrees = new Map<string, number>();
+	private nodes = new Map<string, TestNode>();
+
+	constructor(
+		private readonly graph: Graph<TestNode, TestEdge>,
+		directed = false
+	) {
+		for (const node of graph.getAllNodes()) {
+			this.nodes.set(node.id, node);
+			this.adjacency.set(node.id, []);
+		}
+
+		for (const edge of graph.getAllEdges()) {
+			const neighbors = this.adjacency.get(edge.source) ?? [];
+			neighbors.push({ targetId: edge.target, relationshipType: edge.type ?? "edge" });
+			this.adjacency.set(edge.source, neighbors);
+
+			if (!directed) {
+				const reverseNeighbors = this.adjacency.get(edge.target) ?? [];
+				reverseNeighbors.push({ targetId: edge.source, relationshipType: edge.type ?? "edge" });
+				this.adjacency.set(edge.target, reverseNeighbors);
+			}
+		}
+
+		for (const [nodeId, neighbors] of this.adjacency) {
+			this.degrees.set(nodeId, neighbors.length);
+		}
+	}
+
+	async getNeighbors(nodeId: string): Promise<Neighbor[]> {
+		return this.adjacency.get(nodeId) ?? [];
+	}
+
+	getDegree(nodeId: string): number {
+		return this.degrees.get(nodeId) ?? 0;
+	}
+
+	async getNode(nodeId: string): Promise<TestNode | null> {
+		return this.nodes.get(nodeId) ?? null;
+	}
+
+	addEdge(): void {
+		// No-op
+	}
+
+	calculatePriority(nodeId: string, options: { nodeWeight?: number; epsilon?: number } = {}): number {
+		const { nodeWeight = 1, epsilon = 1e-10 } = options;
+		const degree = this.getDegree(nodeId);
+		return degree / (nodeWeight + epsilon);
+	}
+
+	getAllDegrees(): Map<string, number> {
+		return this.degrees;
+	}
+}
+
+/**
+ * Create a test graph from edge list
+ */
+export const createGraph = (edges: Array<[string, string]>): Graph<TestNode, TestEdge> => {
+	const graph = new Graph<TestNode, TestEdge>(false);
+
+	const nodeIds = new Set<string>();
+	for (const [source, target] of edges) {
+		nodeIds.add(source);
+		nodeIds.add(target);
+	}
+
+	for (const id of nodeIds) {
+		graph.addNode({ id, type: "test" });
+	}
+
+	let edgeCounter = 0;
+	for (const [source, target] of edges) {
+		graph.addEdge({ id: `e${edgeCounter++}`, source, target, type: "edge" });
+		graph.addEdge({ id: `e${edgeCounter++}`, source: target, target: source, type: "edge" });
+	}
+
+	return graph;
+};
+
+/**
+ * Create a chain graph (linear path)
+ */
+export const createChainGraph = (length: number): Graph<TestNode, TestEdge> => {
+	const edges: Array<[string, string]> = [];
+	for (let index = 0; index < length - 1; index++) {
+		edges.push([`N${index}`, `N${index + 1}`]);
+	}
+	return createGraph(edges);
+};
+
+/**
+ * Create a grid graph (rows x cols)
+ */
+export const createGridGraph = (rows: number, cols: number): Graph<TestNode, TestEdge> => {
+	const edges: Array<[string, string]> = [];
+
+	for (let r = 0; r < rows; r++) {
+		for (let c = 0; c < cols; c++) {
+			const node = `${r}_${c}`;
+			if (c < cols - 1) {
+				edges.push([node, `${r}_${c + 1}`]);
+			}
+			if (r < rows - 1) {
+				edges.push([node, `${r + 1}_${c}`]);
+			}
+		}
+	}
+
+	return createGraph(edges);
+};
+
+/**
+ * Create a hub graph with central hub nodes and leaf nodes
+ */
+export const createHubGraph = (numberHubs: number, leavesPerHub: number): Graph<TestNode, TestEdge> => {
+	const edges: Array<[string, string]> = [];
+
+	// Connect hubs
+	for (let index = 0; index < numberHubs; index++) {
+		for (let index_ = index + 1; index_ < numberHubs; index_++) {
+			edges.push([`H${index}`, `H${index_}`]);
+		}
+	}
+
+	// Connect leaves
+	for (let h = 0; h < numberHubs; h++) {
+		for (let l = 0; l < leavesPerHub; l++) {
+			edges.push([`H${h}`, `L${h}_${l}`]);
+		}
+	}
+
+	return createGraph(edges);
+};

src/experiments/evaluation/__tests__/validation/common/representativeness-helpers.ts

@@ -10,7 +10,7 @@
 import { describe, expect, it } from "vitest";
 
 import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
-import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
+import { StandardBfsExpansion } from "../../../../../experiments/baselines/standard-bfs"
 import { createHubGraphExpander } from "../common/graph-generators";
 import { jaccardSimilarity } from "../common/statistical-functions";
 

src/experiments/evaluation/__tests__/validation/comparative/comparative-summary.integration.test.ts

@@ -12,11 +12,11 @@
 
 import { describe, expect, it } from "vitest";
 
-import { BenchmarkGraphExpander } from "../../common/benchmark-graph-expander";
-import { loadBenchmarkByIdFromUrl } from "../../../../fixtures/benchmark-datasets";
+import { BenchmarkGraphExpander } from "../common/benchmark-graph-expander";
+import { loadBenchmarkByIdFromUrl } from "../../../fixtures/benchmark-datasets";
 import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
-import { StandardBfsExpansion } from "../../../baselines/standard-bfs";
-import { pathDiversity } from "../../common/statistical-functions";
+import { StandardBfsExpansion } from "../../../../../experiments/baselines/standard-bfs"
+import { pathDiversity } from "../common/statistical-functions";
 
 describe("Systematic Literature Review Metrics", () => {
 	/**

src/experiments/evaluation/__tests__/validation/comparative/literature-review-metrics.integration.test.ts

@@ -8,14 +8,14 @@
 import { describe, expect, it } from "vitest";
 
 import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
-import { BenchmarkGraphExpander } from "../../common/benchmark-graph-expander";
+import { BenchmarkGraphExpander } from "../common/benchmark-graph-expander";
 import { loadBenchmarkByIdFromUrl } from "../../../fixtures/benchmark-datasets";
-import { HighDegreeFirstExpansion } from "../../common/baselines/high-degree-first";
-import { LowDegreeFirstExpansion } from "../../common/baselines/low-degree-first";
-import { FrontierBalancedExpansion } from "../../../../baselines/frontier-balanced";
-import { RandomPriorityExpansion } from "../../../../baselines/random-priority";
-import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
-import { pathDiversity } from "../../common/statistical-functions";
+import { HighDegreeFirstExpansion } from "../common/baselines/high-degree-first";
+import { LowDegreeFirstExpansion } from "../common/baselines/low-degree-first";
+import { FrontierBalancedExpansion } from "../../../../../experiments/baselines/frontier-balanced"
+import { RandomPriorityExpansion } from "../../../../../experiments/baselines/random-priority"
+import { StandardBfsExpansion } from "../../../../../experiments/baselines/standard-bfs"
+import { pathDiversity } from "../common/statistical-functions";
 
 describe("Thesis Validation: Additional Baselines", () => {
 	it("should compare thesis method vs high-degree-first baseline", async () => {

src/experiments/evaluation/__tests__/validation/comparative/method-ranking.integration.test.ts

@@ -8,13 +8,13 @@
 
 import { describe, expect, it } from "vitest";
 
-import { DegreePrioritisedExpansion } from "../../../../algorithms/traversal/degree-prioritised-expansion";
+import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
 
 import { BenchmarkGraphExpander } from "../common/benchmark-graph-expander";
 import { loadBenchmarkByIdFromUrl } from "../../../fixtures/benchmark-datasets";
-import { FrontierBalancedExpansion } from "../../../../baselines/frontier-balanced";
-import { RandomPriorityExpansion } from "../../../../baselines/random-priority";
-import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
+import { FrontierBalancedExpansion } from "../../../../../experiments/baselines/frontier-balanced"
+import { RandomPriorityExpansion } from "../../../../../experiments/baselines/random-priority"
+import { StandardBfsExpansion } from "../../../../../experiments/baselines/standard-bfs"
 import { cohensD, confidenceInterval, mannWhitneyUTest } from "../common/statistical-functions";
 
 describe("Thesis Validation: Statistical Tests", () => {

src/experiments/evaluation/__tests__/validation/comparative/multi-method-comparison.integration.test.ts

@@ -15,7 +15,7 @@ import {
 	loadBenchmarkFromContent,
 } from "../../../fixtures/benchmark-datasets";
 import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
-import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
+import { StandardBfsExpansion } from "../../../../../experiments/baselines/standard-bfs"
 import { pathDiversity } from "../common/statistical-functions";
 
 describe("Thesis Validation: Perturbed Graph Robustness", () => {

src/experiments/evaluation/__tests__/validation/comparative/perturbation-consistency.integration.test.ts

@@ -15,7 +15,7 @@ import {
 	loadBenchmarkFromContent,
 } from "../../../fixtures/benchmark-datasets";
 import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
-import { StandardBfsExpansion } from "../../../../baselines/standard-bfs";
+import { StandardBfsExpansion } from "../../../../../experiments/baselines/standard-bfs"
 import { jaccardSimilarity, pathDiversity } from "../common/statistical-functions";
 
 // ============================================================================

src/experiments/evaluation/__tests__/validation/comparative/validation-summary.integration.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { BenchmarkGraphExpander } from "../../common/benchmark-graph-expander";
+import { BenchmarkGraphExpander } from "../common/benchmark-graph-expander";
 import { loadBenchmarkByIdFromUrl } from "../../../fixtures/benchmark-datasets";
-import { DegreePrioritisedExpansion } from "../../../../baselines/degree-prioritised-expansion";
-import { StandardBfsExpansion } from "../../../../baselines/standard-bfs-expansion";
-import { RandomPriorityExpansion } from "../../../../baselines/random-priority-expansion";
-import { mannWhitneyUTest, cohensD, confidenceInterval, pathDiversity } from "../../common/statistical-functions";
+import { DegreePrioritisedExpansion } from "../../../../../algorithms/traversal/degree-prioritised-expansion";
+import { StandardBfsExpansion } from "../../../../../experiments/baselines/standard-bfs"
+import { RandomPriorityExpansion } from "../../../../../experiments/baselines/random-priority"
+import { mannWhitneyUTest, cohensD, confidenceInterval, pathDiversity } from "../common/statistical-functions";
 
 describe("Thesis Validation: Variability Injection", () => {
 	describe("Multiple Seed Pair Analysis", () => {