@vespermcp/mcp-server 1.0.0

package/build/scripts/test-observability.js

@@ -0,0 +1,106 @@
+import { MetadataStore } from "../metadata/store.js";
+import { JobManager } from "../jobs/manager.js";
+import { ObservabilityService, MockErrorTracker } from "../monitoring/observability.js";
+import path from "path";
+async function runTest() {
+    console.log("--- Initializing Enhanced Observability Test ---");
+    const dbPath = path.resolve("data", "test-obs-10.db");
+    const store = new MetadataStore(dbPath);
+    const errorTracker = new MockErrorTracker();
+    const stats = new ObservabilityService(errorTracker);
+    const manager = JobManager.getInstance(store, stats);
+    manager.setConcurrency(5); // Increased for faster test
+    const jobsToRun = 10;
+    // Listener to simulate job processing
+    manager.on("processJob", async (job, run) => {
+        // Fix: Parse JSON metadata correctly
+        const meta = job.metadata ? JSON.parse(job.metadata) : null;
+        const isFailing = meta === "FAIL";
+        const isSlow = meta === "SLOW";
+        await run(async () => {
+            // Simulated delay: 100ms for fast, 800ms for slow
+            const delay = isSlow ? 800 : 100;
+            await new Promise(r => setTimeout(r, delay));
+            if (isFailing) {
+                console.log(`[Worker] Failing Job: ${job.id}`);
+                throw new Error("Simulated job failure for metrics tracking");
+            }
+            console.log(`[Worker] Finished Job: ${job.id}`);
+        });
+    });
+    console.log(`\nEnqueuing ${jobsToRun} mixed jobs...`);
+    // Enqueue 10 mixed jobs
+    // [Success, Success, FAIL, SlowSuccess, FAIL, Success, Success, SlowSuccess, FAIL, Success] -> 7 Success, 3 Fail
+    const jobConfig = [
+        { type: "clean", meta: "SUCCESS" }, // 1
+        { type: "prepare", meta: "SUCCESS" }, // 2
+        { type: "fusion", meta: "FAIL" }, // 3
+        { type: "clean", meta: "SLOW" }, // 4
+        { type: "prepare", meta: "FAIL" }, // 5
+        { type: "fusion", meta: "SUCCESS" }, // 6
+        { type: "clean", meta: "SUCCESS" }, // 7
+        { type: "prepare", meta: "SLOW" }, // 8
+        { type: "fusion", meta: "FAIL" }, // 9
+        { type: "clean", meta: "SUCCESS" } // 10
+    ];
+    for (const conf of jobConfig) {
+        // Fix: Use maxAttempts: 1 to avoid retries and get immediate metrics
+        manager.createJob(conf.type, 0, conf.meta, 1);
+    }
+    // Monitor for completion
+    return new Promise((resolve) => {
+        const interval = setInterval(() => {
+            const currentStats = stats.getStats();
+            const totalFinished = Object.values(currentStats).reduce((acc, s) => acc + s.successCount + s.failureCount, 0);
+            if (totalFinished >= jobsToRun) {
+                clearInterval(interval);
+                verify(stats, errorTracker, resolve);
+            }
+        }, 500);
+    });
+}
+function verify(stats, errorTracker, resolve) {
+    console.log("\n--- Verification Results ---");
+    const prometheus = stats.getPrometheusMetrics();
+    const summary = stats.getStats();
+    const actualSuccess = Object.values(summary).reduce((acc, s) => acc + s.successCount, 0);
+    const actualFailure = Object.values(summary).reduce((acc, s) => acc + s.failureCount, 0);
+    console.log(`Measured Success: ${actualSuccess} (Expected 7)`);
+    console.log(`Measured Failure: ${actualFailure} (Expected 3)`);
+    let failed = false;
+    if (actualSuccess === 7 && actualFailure === 3) {
+        console.log("✅ Jobs processed/hour (total counts) verified.");
+    }
+    else {
+        console.error("❌ Stats mismatch.");
+        failed = true;
+    }
+    // 2. Verify Latency Histogram
+    const hasLatency = prometheus.includes("job_duration_seconds_sum");
+    const maxLatencyClean = summary.clean?.maxDuration;
+    console.log(`Max Latency (clean): ${maxLatencyClean} (Expected > 100ms)`);
+    if (hasLatency && parseFloat(maxLatencyClean) > 0) {
+        console.log("✅ Latency histogram contains recorded values.");
+    }
+    else {
+        console.error("❌ Latency data missing.");
+        failed = true;
+    }
+    // 3. Mock Sentry / Error Tracking Verification
+    console.log(`Exceptions Captured: ${errorTracker.exceptions.length} (Expected 3)`);
+    if (errorTracker.exceptions.length === 3) {
+        console.log("✅ Error tracking successfully logged all failed jobs.");
+    }
+    else {
+        console.error("❌ Error tracking mismatch.");
+        failed = true;
+    }
+    if (!failed) {
+        console.log("\n✅ Success: Enhanced observability verification complete.");
+    }
+    else {
+        console.error("\n❌ Failure: Observability verification failed.");
+    }
+    resolve();
+}
+runTest().catch(console.error);

package/build/scripts/test-packager.js

@@ -0,0 +1,55 @@
+import { MetadataPackager } from "../export/packager.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Metadata Packager Test ===\n");
+    const packager = new MetadataPackager();
+    const testDir = path.join(process.cwd(), "test_package_input");
+    const outputDir = path.join(process.cwd(), "test_package_output");
+    if (!fs.existsSync(testDir))
+        fs.mkdirSync(testDir);
+    if (fs.existsSync(outputDir))
+        fs.rmSync(outputDir, { recursive: true, force: true });
+    // 1. Create Mock Data
+    const dataPath = path.join(testDir, "train.csv");
+    fs.writeFileSync(dataPath, "id,value\n1,10\n2,20\n");
+    const qualityReport = {
+        score: 85,
+        issues: ["Missing values in column 'label'"]
+    };
+    const metadata = {
+        name: "Test Dataset",
+        version: "1.0.0",
+        description: "A test dataset for packaging",
+        license: "MIT",
+        author: "Vesper Team",
+        tags: ["test", "ml"]
+    };
+    // 2. Create Package
+    console.log("Creating package...");
+    const result = await packager.createPackage(outputDir, [{ path: dataPath, format: "csv", name: "training-data" }], metadata, { qualityReport });
+    console.log("Result:", JSON.stringify(result, null, 2));
+    if (result.success) {
+        console.log("\nVerifying files in output...");
+        const files = fs.readdirSync(outputDir);
+        console.log("Files found:", files);
+        if (files.includes("datapackage.json") && files.includes("train.csv") && files.includes("quality_report.json")) {
+            console.log("PASS: All files present in package");
+            const manifest = JSON.parse(fs.readFileSync(path.join(outputDir, "datapackage.json"), "utf8"));
+            console.log("Manifest resources count:", manifest.resources.length);
+            if (manifest.resources.length === 2 && manifest.resources[0].hash.startsWith("sha256:")) {
+                console.log("PASS: Manifest entry and hash verified");
+            }
+        }
+        else {
+            console.error("FAIL: Missing files in package");
+        }
+    }
+    else {
+        console.error("FAIL: Packaging failed:", result.error);
+    }
+    // Cleanup
+    // fs.rmSync(testDir, { recursive: true, force: true });
+    // fs.rmSync(outputDir, { recursive: true, force: true });
+}
+main().catch(console.error);

package/build/scripts/test-pipeline.js

@@ -0,0 +1,50 @@
+import { PipelineExecutor } from "../cleaning/executor.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Full Pipeline Test ===\n");
+    const executor = new PipelineExecutor();
+    const testFile = path.join(process.cwd(), "test_pipeline.csv");
+    // Create Dirty Data
+    // - duplicate: Duplicate row
+    // - empty: 100% missing (should drop)
+    // - price: "100.5" string (should fix type)
+    const csvContent = `id,price,empty,desc
+1,"100.5",,A
+2,"50.2",,B
+1,"100.5",,A
+3,"75.0",,C`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created dirty file: ${testFile}`);
+    try {
+        console.log("\nRunning Pipeline...");
+        const result = await executor.runPipeline("test-pipeline-ds", testFile);
+        console.log("\n=== Pipeline Report ===");
+        console.log(`Plan Generated: ${result.plan.operations.length} operations`);
+        // Assertions
+        const ops = result.plan.operations.map(o => o.type);
+        console.log("Operations:", ops);
+        const hasDedupe = ops.includes("RemoveDuplicates");
+        const hasDrop = ops.includes("DropColumns");
+        const hasFix = ops.includes("FixTypes");
+        if (hasDedupe && hasDrop && hasFix) {
+            console.log("Plan Logic: PASS (Generated precise cleaning steps)");
+        }
+        else {
+            console.error("Plan Logic: FAIL (Missed some cleaning steps)");
+        }
+        if (result.cleaning_result.success && fs.existsSync(result.final_output_path)) {
+            console.log("Execution: PASS (Created cleaned file)");
+            // Cleanup
+            fs.unlinkSync(testFile);
+            fs.unlinkSync(result.final_output_path);
+        }
+        else {
+            console.error("Execution: FAIL");
+        }
+    }
+    catch (error) {
+        console.error("\nTest failed:", error);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-planning.js

@@ -0,0 +1,64 @@
+import { CleaningPlanner } from "../cleaning/planner.js";
+async function main() {
+    console.log("=== Vesper Cleaning Planner Test ===\n");
+    const planner = new CleaningPlanner();
+    // Mock Report
+    const mockReport = {
+        row_count: 1000,
+        column_count: 4,
+        duplicate_rows: 50,
+        duplicate_percentage: 5.0,
+        columns: [
+            {
+                name: "id", type: "Int64", inferred_type: "Int64",
+                missing_count: 0, missing_percentage: 0, unique_count: 1000,
+                is_constant: false, is_mixed_type: false
+            },
+            {
+                name: "empty_col", type: "String", inferred_type: "String",
+                missing_count: 950, missing_percentage: 95.0, unique_count: 1,
+                is_constant: false, is_mixed_type: false
+            },
+            {
+                name: "age", type: "String", inferred_type: "Numeric (Stored as String)",
+                missing_count: 10, missing_percentage: 1.0, unique_count: 50,
+                is_constant: false, is_mixed_type: false
+            },
+            {
+                name: "score", type: "Float64", inferred_type: "Float64",
+                missing_count: 5, missing_percentage: 0.5, unique_count: 900,
+                is_constant: false, is_mixed_type: false
+            }
+        ],
+        warnings: [],
+        schema_warnings: [],
+        overall_score: 50
+    };
+    console.log("Input Scenario:");
+    console.log("- 50 duplicate rows -> Expect RemoveDuplicates");
+    console.log("- 'empty_col' (95% missing) -> Expect DropColumns");
+    console.log("- 'age' (String but looks Numeric) -> Expect FixTypes");
+    console.log("- 'score' (Missing values) -> Expect FillMissing");
+    const plan = await planner.generatePlan("test-dataset", mockReport);
+    console.log("\n=== Generated Plan ===");
+    plan.operations.forEach((op, i) => {
+        console.log(`${i + 1}. [${op.type}] Reason: ${op.reason}`);
+        if (op.params && Object.keys(op.params).length > 0) {
+            console.log(`   Params: ${JSON.stringify(op.params)}`);
+        }
+    });
+    // Verification
+    const types = plan.operations.map(o => o.type);
+    const hasDedupe = types.includes("RemoveDuplicates");
+    const hasDrop = types.includes("DropColumns");
+    const hasFix = types.includes("FixTypes");
+    const hasFill = types.includes("FillMissing");
+    if (hasDedupe && hasDrop && hasFix && hasFill) {
+        console.log("\nTest passed! All expected operations generated.");
+    }
+    else {
+        console.error("\nTest failed! Missing expected operations.");
+        console.log("Found:", types);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-privacy.js

@@ -0,0 +1,38 @@
+import { QualityAnalyzer } from "../quality/analyzer.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Privacy Scanner Test ===\n");
+    const analyzer = new QualityAnalyzer();
+    const testFile = path.join(process.cwd(), "test_privacy.csv");
+    // Create a CSV with PII
+    const csvContent = `id,name,contact,notes
+1,John Doe,john@example.com,"User IP: 192.168.1.1"
+2,Jane Smith,(555) 123-4567,"SSN is 123-45-6789"
+3,Bob Jones,bob@work.com,"Safe notes"`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created test file: ${testFile}`);
+    console.log("Expectations:");
+    console.log("  - Should detect 'Email' in 'contact' column");
+    console.log("  - Should detect 'Phone' in 'contact' column");
+    console.log("  - Should detect 'SSN' in 'notes' column");
+    console.log("  - Should detect 'IPv4' in 'notes' column");
+    try {
+        console.log("\nRunning analyzer...");
+        const report = await analyzer.analyze(testFile);
+        console.log("\n=== Privacy Report ===");
+        if (report.pii_warnings && report.pii_warnings.length > 0) {
+            report.pii_warnings.forEach(w => console.log(`[!] ${w}`));
+            console.log("\nTest passed! PII detected.");
+        }
+        else {
+            console.error("\nTest failed! No PII detected.");
+        }
+        // Cleanup
+        fs.unlinkSync(testFile);
+    }
+    catch (error) {
+        console.error("\nTest failed:", error);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-quality.js

@@ -0,0 +1,43 @@
+import { QualityAnalyzer } from "../quality/analyzer.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Quality Analysis Test ===\n");
+    const analyzer = new QualityAnalyzer();
+    const testFile = path.join(process.cwd(), "test_data.csv");
+    // 1. Create a dummy CSV with some issues
+    const csvContent = `id,age,score,category
+1,25,90.5,A
+2,30,88.0,B
+3,,75.0,A
+4,25,90.5,A
+5,150,12.0,C
+6,40,99.9,B`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created test file: ${testFile}`);
+    console.log("Data contains: 1 missing value, 1 duplicate row, 1 outlier (age 150)\n");
+    try {
+        console.log("Running analyzer...");
+        const report = await analyzer.analyze(testFile);
+        console.log("\n=== Analysis Report ===");
+        console.log(`Rows: ${report.row_count}, Columns: ${report.column_count}`);
+        console.log(`Duplicates: ${report.duplicate_rows} (${report.duplicate_percentage.toFixed(1)}%)`);
+        console.log("\nColumn Details:");
+        for (const col of report.columns) {
+            let details = "";
+            if (col.missing_count > 0)
+                details += `Missing: ${col.missing_count} `;
+            if (col.distribution)
+                details += `Mean: ${col.distribution.mean.toFixed(1)} `;
+            console.log(`  - ${col.name} (${col.type}): ${details}`);
+        }
+        console.log("\nWarnings:", report.warnings);
+        // Cleanup
+        fs.unlinkSync(testFile);
+        console.log("\nTest passed!");
+    }
+    catch (error) {
+        console.error("\nTest failed:", error);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-robust-ingestion.js

@@ -0,0 +1,41 @@
+import { RobustDownloader } from "../utils/downloader.js";
+import fs from "fs";
+import path from "path";
+async function runTest() {
+    console.log("--- Testing Robust Ingestion (Resume Support) ---");
+    const downloader = new RobustDownloader();
+    const testDir = path.resolve("./data/test-ingestion");
+    if (!fs.existsSync(testDir))
+        fs.mkdirSync(testDir, { recursive: true });
+    const targetPath = path.join(testDir, "test-file.txt");
+    const testUrl = "https://raw.githubusercontent.com/google/guava/master/LICENSE";
+    // 1. Pre-fill with partial garbage content
+    console.log("Simulating a partial download (first 50 bytes)...");
+    fs.writeFileSync(targetPath, "This is some existing content that should be ignored by Range 0 but appended if we resume.");
+    const initialSize = fs.statSync(targetPath).size;
+    console.log(`Initial file size: ${initialSize} bytes`);
+    // 2. Attempt Download with Resume
+    console.log("Starting downloader with resume=true...");
+    try {
+        await downloader.download(testUrl, targetPath, {
+            resume: true,
+            onProgress: (bytes, total) => {
+                console.log(`Progress: ${bytes}/${total} bytes`);
+            }
+        });
+        const finalSize = fs.statSync(targetPath).size;
+        console.log(`Final file size: ${finalSize} bytes`);
+        if (finalSize > initialSize) {
+            console.log("\nVERIFICATION_STATUS: ✅ PASS (Resumed and finished)");
+        }
+        else {
+            console.log("\nVERIFICATION_STATUS: ❌ FAIL (File did not grow)");
+        }
+    }
+    catch (e) {
+        console.error("Download failed:", e.message);
+        // Note: github raw might not support ranges perfectly, but the logic check stands
+        console.log("\nVERIFICATION_STATUS: ❌ FAIL");
+    }
+}
+runTest().catch(console.error);

package/build/scripts/test-schema.js

@@ -0,0 +1,45 @@
+import { QualityAnalyzer } from "../quality/analyzer.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Schema Validation Test ===\n");
+    const analyzer = new QualityAnalyzer();
+    const testFile = path.join(process.cwd(), "test_schema.csv");
+    // Create a CSV with schema issues
+    // 'price': stored as string (should be numeric)
+    // 'mixed': completely broken mixed types
+    const csvContent = `id,price,mixed,valid_str
+1,"100.5",10,A
+2,"50.2","text",B
+3,"75.0",20,A
+4,"200",30,C
+5,"10.99","oops",B`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created test file: ${testFile}`);
+    console.log("Expectations:");
+    console.log("  - 'price' should be detected as Numeric (Stored as String)");
+    console.log("  - 'mixed' should be flagged as Mixed Type");
+    try {
+        console.log("\nRunning analyzer...");
+        const report = await analyzer.analyze(testFile);
+        console.log("\n=== Schema Report ===");
+        for (const col of report.columns) {
+            console.log(`Column: ${col.name}`);
+            console.log(`  Type: ${col.type}`);
+            console.log(`  Inferred: ${col.inferred_type}`);
+            if (col.is_mixed_type)
+                console.log(`  [!] Mixed Type Detected`);
+            if (col.inferred_type !== col.type && !col.type.includes(col.inferred_type)) {
+                console.log(`  [!] Type Mismatch Detected`);
+            }
+        }
+        console.log("\nSchema Warnings:", report.schema_warnings);
+        // Cleanup
+        fs.unlinkSync(testFile);
+        console.log("\nTest passed!");
+    }
+    catch (error) {
+        console.error("\nTest failed:", error);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-split-validation.js

@@ -0,0 +1,40 @@
+import { DataSplitter } from "../splitting/splitter.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Split Validation Test ===\n");
+    const splitter = new DataSplitter();
+    const trainPath = path.join(process.cwd(), "mock_train.csv");
+    const valPath = path.join(process.cwd(), "mock_val.csv");
+    const testPath = path.join(process.cwd(), "mock_test.csv");
+    // 1. Create splits with LEAKAGE (ID 1 exists in train and val)
+    // And DRIFT (Train is all 'A', Val is all 'B')
+    fs.writeFileSync(trainPath, "id,label\n1,A\n2,A\n3,A");
+    fs.writeFileSync(valPath, "id,label\n1,B\n4,B\n5,B"); // ID 1 is leak
+    fs.writeFileSync(testPath, "id,label\n6,A\n7,B");
+    try {
+        console.log("Running validator...");
+        const report = await splitter.validate({ train: trainPath, val: valPath, test: testPath }, { id_column: "id", target_column: "label" });
+        console.log("\n=== Validation Report ===");
+        console.log(`Leakage Detected: ${report.leakage_detected} (Count: ${report.leakage_count})`);
+        console.log(`Distribution Mismatch: ${report.distribution_mismatch}`);
+        console.log("Warnings:");
+        report.warnings.forEach(w => console.log(`  - ${w}`));
+        // Assertions
+        if (report.leakage_detected && report.distribution_mismatch) {
+            console.log("\nPASS: Detected both Leakage and Drift.");
+        }
+        else {
+            console.error("\nFAIL: Missed issues.");
+        }
+    }
+    catch (e) {
+        console.error("Test failed:", e);
+    }
+    finally {
+        // Cleanup
+        [trainPath, valPath, testPath].forEach(p => { if (fs.existsSync(p))
+            fs.unlinkSync(p); });
+    }
+}
+main().catch(console.error);

package/build/scripts/test-splitter.js

@@ -0,0 +1,93 @@
+import { DataSplitter } from "../splitting/splitter.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Data Splitter Test ===\n");
+    const splitter = new DataSplitter();
+    const testFile = path.join(process.cwd(), "test_splitting.csv");
+    // Create Dummy Data
+    // - id: 1..100
+    // - label: A (50), B (50) for stratification
+    // - date: sequential dates for time split
+    let csvContent = "id,label,date\n";
+    for (let i = 0; i < 50; i++)
+        csvContent += `${i},A,2023-01-${(i % 30) + 1}\n`;
+    for (let i = 50; i < 100; i++)
+        csvContent += `${i},B,2023-02-${(i % 28) + 1}\n`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created test file: ${testFile}`);
+    console.log("Rows: 100 (50 A, 50 B)");
+    // Test 1: Random Split (80/10/10)
+    console.log("\n--- Test 1: Random Split (80/10/10) ---");
+    const config1 = {
+        type: "random",
+        ratios: { train: 0.8, val: 0.1, test: 0.1, holdout: 0 },
+        shuffle: true,
+        random_seed: 42
+    };
+    try {
+        const result1 = await splitter.split(testFile, config1);
+        console.log("Stats:", result1.stats);
+        if (result1.stats.train_rows === 80 && result1.stats.val_rows === 10 && result1.stats.test_rows === 10) {
+            console.log("PASS: Ratios preserved");
+        }
+        else {
+            console.error("FAIL: Incorrect ratios");
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    // Test 2: Stratified Split (60/20/20) on 'label'
+    console.log("\n--- Test 2: Stratified Split (60/20/20) ---");
+    const config2 = {
+        type: "stratified",
+        ratios: { train: 0.6, val: 0.2, test: 0.2, holdout: 0 },
+        target_column: "label",
+        random_seed: 42
+    };
+    try {
+        const result2 = await splitter.split(testFile, config2);
+        console.log("Stats:", result2.stats);
+        if (result2.stats.train_rows === 60 && result2.stats.val_rows === 20 && result2.stats.test_rows === 20) {
+            console.log("PASS: Ratios preserved");
+            // In a deeper test we would verify the class distribution too, but simple count is good for now
+        }
+        else {
+            console.error("FAIL: Incorrect ratios");
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    // Test 3: Time Split (70/15/15) on 'date'
+    console.log("\n--- Test 3: Time Split (70/15/15) ---");
+    const config3 = {
+        type: "time",
+        ratios: { train: 0.7, val: 0.15, test: 0.15, holdout: 0 },
+        time_column: "date"
+    };
+    try {
+        const result3 = await splitter.split(testFile, config3);
+        console.log("Stats:", result3.stats);
+        // Clean up generated files
+        fs.unlinkSync(result3.paths.train);
+        fs.unlinkSync(result3.paths.val);
+        fs.unlinkSync(result3.paths.test);
+        // Clean up previous test files too (using known naming convention)
+        const base = testFile.replace(".csv", "");
+        if (fs.existsSync(base + "_train.csv"))
+            fs.unlinkSync(base + "_train.csv");
+        if (fs.existsSync(base + "_val.csv"))
+            fs.unlinkSync(base + "_val.csv");
+        if (fs.existsSync(base + "_test.csv"))
+            fs.unlinkSync(base + "_test.csv");
+        console.log("PASS: Execution successful");
+    }
+    catch (e) {
+        console.error(e);
+    }
+    // Cleanup input
+    fs.unlinkSync(testFile);
+}
+main().catch(console.error);

package/build/scripts/test-uci.js

@@ -0,0 +1,27 @@
+import { UCIScraper } from "../metadata/uci-scraper.js";
+async function runTest() {
+    console.log("--- Testing UCI integration ---");
+    const scraper = new UCIScraper();
+    const query = "iris";
+    console.log(`Searching UCI for: "${query}"...`);
+    const results = await scraper.scrape(query, 5);
+    console.log(`Found ${results.length} datasets.`);
+    if (results.length > 0) {
+        console.log("✅ UCI Scraper returned results.");
+        console.log("Sample Result:");
+        console.log(JSON.stringify(results[0], null, 2));
+        // Validation
+        const sample = results[0];
+        if (sample.id.startsWith("uci:") && sample.source === "uci") {
+            console.log("✅ Metadata schema validation passed.");
+        }
+        else {
+            console.error("❌ Metadata schema validation failed.");
+        }
+    }
+    else {
+        console.error("❌ No results found. Ensure python and ucimlrepo are installed.");
+    }
+    console.log("--- Test Complete ---");
+}
+runTest().catch(console.error);