@vespermcp/mcp-server 1.0.0

package/build/scripts/demo-ui.js

@@ -0,0 +1,58 @@
+import { SearchEngine } from "../search/engine.js";
+import { MetadataStore } from "../metadata/store.js";
+import { VectorStore } from "../search/vector-store.js";
+import { Embedder } from "../search/embedder.js";
+import { formatSearchResults, formatDatasetInfo } from "../tools/formatter.js";
+import path from "path";
+/**
+ * Demo script to showcase the new formatted UI
+ */
+async function main() {
+    const dbPath = path.join(process.cwd(), "data", "metadata.db");
+    const vectorPath = path.join(process.cwd(), "data", "vectors.json");
+    const store = new MetadataStore(dbPath);
+    const vectorStore = new VectorStore(vectorPath);
+    const embedder = Embedder.getInstance();
+    await embedder.init();
+    const engine = new SearchEngine(store, vectorStore, embedder);
+    console.log("\n" + "═".repeat(80));
+    console.log("VESPER UI DEMO - Formatted Search Results");
+    console.log("═".repeat(80) + "\n");
+    // Demo 1: Medical datasets
+    console.log("Demo 1: Medical Dataset Search\n");
+    const medicalResults = await engine.search("diabetes prediction machine learning", {
+        limit: 3,
+        safeOnly: true
+    });
+    console.log(formatSearchResults(medicalResults));
+    // Demo 2: Detailed dataset info
+    if (medicalResults.length > 0) {
+        console.log("\n" + "═".repeat(80));
+        console.log("Demo 2: Detailed Dataset Information");
+        console.log("═".repeat(80) + "\n");
+        console.log(formatDatasetInfo(medicalResults[0]));
+    }
+    // Demo 3: Computer Vision
+    console.log("\n" + "═".repeat(80));
+    console.log("Demo 3: Computer Vision Dataset Search");
+    console.log("═".repeat(80) + "\n");
+    const cvResults = await engine.search("image classification cats dogs", {
+        limit: 3,
+        safeOnly: true
+    });
+    console.log(formatSearchResults(cvResults));
+    // Demo 4: Show quality warnings
+    console.log("\n" + "═".repeat(80));
+    console.log("Demo 4: Niche Query with Quality Warnings");
+    console.log("═".repeat(80) + "\n");
+    const nicheResults = await engine.search("ancient manuscript text recognition", {
+        limit: 3,
+        safeOnly: true
+    });
+    console.log(formatSearchResults(nicheResults));
+    console.log("\n" + "═".repeat(80));
+    console.log("Demo Complete!");
+    console.log("═".repeat(80) + "\n");
+    store.close();
+}
+main().catch(console.error);

package/build/scripts/e2e-demo.js

@@ -0,0 +1,72 @@
+import { QualityAnalyzer } from "../quality/analyzer.js";
+import { PipelineExecutor } from "../cleaning/executor.js";
+import { DataSplitter } from "../splitting/splitter.js";
+import { MetadataPackager } from "../export/packager.js";
+import { DataExporter } from "../export/exporter.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log(" Vesper Data Ops Engine - End-to-End Pipeline Demo\n");
+    const sessionDir = path.join(process.cwd(), "e2e_demo_output");
+    if (fs.existsSync(sessionDir))
+        fs.rmSync(sessionDir, { recursive: true, force: true });
+    fs.mkdirSync(sessionDir);
+    const rawFile = path.join(sessionDir, "raw_data.csv");
+    // --- STEP 0: Create Raw "Dirty" Data ---
+    console.log(" Step 0: Initializing Raw Dataset...");
+    let content = "id,name,age,salary,joined_date\n";
+    content += "1,Alice,25,50000,2023-01-01\n";
+    content += "2,Bob,,60000,2023-01-05\n"; // Missing age
+    content += "3,Charlie,35,70000,2023-01-10\n";
+    content += "1,Alice,25,50000,2023-01-01\n"; // Duplicate
+    content += "4,Diana,40,invalid,2023-02-01\n"; // Type mismatch
+    fs.writeFileSync(rawFile, content);
+    // --- STEP 1: Quality Analysis ---
+    console.log(" Step 1: Running Quality Analysis...");
+    const analyzer = new QualityAnalyzer();
+    const report = await analyzer.analyze(rawFile);
+    console.log(`   - Quality Score: ${report.overall_score}/100`);
+    console.log(`   - Warnings Found: ${report.warnings.length}`);
+    // --- STEP 2: Auto-Cleaning ---
+    console.log(" Step 2: Generating and Executing Cleaning Pipeline...");
+    const executor = new PipelineExecutor();
+    const pipelineResult = await executor.runPipeline("demo-dataset", rawFile);
+    const cleanedFile = pipelineResult.final_output_path;
+    console.log(`   - Cleaned file: ${path.basename(cleanedFile)}`);
+    // --- STEP 3: Smart Splitting ---
+    console.log(" Step 3: Splitting into Train/Val/Test/Holdout (Stratified)...");
+    const splitter = new DataSplitter();
+    const splitResult = await splitter.split(cleanedFile, {
+        type: "random", // Using random since dummy data too small for stratified
+        ratios: { train: 0.6, val: 0.2, test: 0.1, holdout: 0.1 },
+        shuffle: true,
+        random_seed: 42
+    });
+    console.log(`   - Splits created: ${Object.keys(splitResult.paths).join(", ")}`);
+    // --- STEP 4: Export to Parquet ---
+    console.log(" Step 4: Exporting Final Train Set to Parquet...");
+    const exporter = new DataExporter();
+    const parquetFile = path.join(sessionDir, "train_final.parquet");
+    await exporter.export(splitResult.paths.train, parquetFile, "parquet");
+    console.log(`   - Exported: ${path.basename(parquetFile)}`);
+    // --- STEP 5: Metadata Packaging ---
+    console.log(" Step 5: Creating Final Data Package...");
+    const packager = new MetadataPackager();
+    const packageResult = await packager.createPackage(path.join(sessionDir, "vesper_package"), [
+        { path: parquetFile, format: "parquet", name: "train-set" },
+        { path: splitResult.paths.holdout, format: "csv", name: "holdout-set" }
+    ], {
+        name: "Vesper E2E Demo",
+        version: "1.0.0",
+        description: "Automatically cleaned and partitioned dataset.",
+        license: "MIT",
+        author: "Vesper Engine"
+    }, { qualityReport: report });
+    console.log(" Pipeline Finished Successfully!");
+    console.log(` Package Location: ${packageResult.packagePath}`);
+    console.log(` Manifest: datapackage.json created.`);
+}
+main().catch(err => {
+    console.error(" Pipeline Failed:", err);
+    process.exit(1);
+});

package/build/scripts/massive-scrape.js

@@ -0,0 +1,103 @@
+import { HuggingFaceScraper } from "../metadata/scraper.js";
+import { KaggleMetadataScraper } from "../metadata/kaggle-scraper.js";
+import { MetadataStore } from "../metadata/store.js";
+import path from "path";
+/**
+ * Realistic massive scraper: Get maximum from HF + extensive Kaggle coverage
+ * Phase 1: Bulk Discovery (Skeleton Indexing)
+ * Phase 2: Kaggle Discovery
+ */
+async function main() {
+    const scraper = new HuggingFaceScraper();
+    const dbPath = path.join(process.cwd(), "data", "metadata.db");
+    const store = new MetadataStore(dbPath);
+    const allDatasets = new Map();
+    try {
+        // Load existing datasets to avoid duplicates
+        console.error(`\nLoading existing datasets from database...`);
+        const existing = store.getAllDatasets();
+        for (const ds of existing) {
+            allDatasets.set(ds.id, ds);
+        }
+        console.error(`Found ${existing.length} existing datasets in database`);
+        // Phase 1: Bulk discovery from HuggingFace
+        console.error(`\nPhase 1: Bulk HuggingFace Discovery (Target: 30,000)`);
+        const hfToken = process.env.HF_TOKEN || process.env.HUGGINGFACE_TOKEN;
+        if (hfToken) {
+            console.error(`Using HuggingFace token (rate limits should be higher)`);
+        }
+        else {
+            console.error(`WARNING: No HF_TOKEN found. Bulk scraping may be slower.`);
+        }
+        const hfLimit = 30000;
+        const hfDatasets = await scraper.scrapeBulk(hfLimit);
+        let newHfCount = 0;
+        for (const ds of hfDatasets) {
+            if (!allDatasets.has(ds.id)) {
+                allDatasets.set(ds.id, ds);
+                newHfCount++;
+            }
+        }
+        console.error(`HuggingFace Bulk Discovery: ${newHfCount} new datasets (${allDatasets.size} total unique)`);
+        // Save HF progress
+        console.error(`Saving HF discovery results to database...`);
+        store.beginTransaction();
+        try {
+            for (const ds of hfDatasets) {
+                store.saveDataset(ds);
+            }
+            store.commit();
+        }
+        catch (e) {
+            store.rollback();
+            console.error("Failed to save HF discovery progress:", e);
+        }
+        // Phase 2: Extensive Kaggle scraping across many categories
+        const kaggleUser = process.env.KAGGLE_USERNAME;
+        const kaggleKey = process.env.KAGGLE_KEY;
+        if (kaggleUser && kaggleKey) {
+            console.error(`\nPhase 2: Extensive Kaggle scraping`);
+            const kaggleScraper = new KaggleMetadataScraper(kaggleUser, kaggleKey);
+            // Comprehensive Kaggle search terms
+            const kaggleSearches = [
+                "machine learning", "deep learning", "data science",
+                "classification", "regression", "clustering", "anomaly detection",
+                "natural language processing", "text classification", "sentiment analysis",
+                "image classification", "object detection", "medical imaging",
+                "time series", "forecasting", "financial forecasting",
+                "healthcare", "medical diagnosis", "e-commerce", "social media"
+            ];
+            for (const search of kaggleSearches) {
+                console.error(`  [Kaggle: "${search}"] Fetching...`);
+                try {
+                    const kaggleDatasets = await kaggleScraper.scrape(search, 100, true);
+                    let newKaggleCount = 0;
+                    for (const ds of kaggleDatasets) {
+                        ds.id = `kaggle:${ds.id}`;
+                        if (!allDatasets.has(ds.id)) {
+                            allDatasets.set(ds.id, ds);
+                            newKaggleCount++;
+                            store.saveDataset(ds); // Save individually to avoid long transactions
+                        }
+                    }
+                    console.error(`    ${newKaggleCount} new datasets (${kaggleDatasets.length} total fetched, ${allDatasets.size} total unique)`);
+                }
+                catch (e) {
+                    console.error(`    ERROR: ${e.message}`);
+                }
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+        }
+        console.error(`\nBulk Discovery Complete!`);
+        console.error(`Total unique datasets in library: ${allDatasets.size}`);
+        console.error(`\nNext step: Run 'npm run index' to update vectors.`);
+    }
+    catch (error) {
+        console.error("\nERROR: Massive scraping failed:", error);
+        process.exit(1);
+    }
+    finally {
+        store.close();
+    }
+}
+main();

package/build/scripts/ops-dashboard.js

@@ -0,0 +1,33 @@
+import { MetadataStore } from "../metadata/store.js";
+import { JobManager } from "../jobs/manager.js";
+import path from "path";
+async function showDashboard() {
+    const dbPath = path.resolve("data", "vesper.db");
+    const store = new MetadataStore(dbPath);
+    // In a real app, this would be a shared instance in a long-running process
+    const manager = JobManager.getInstance(store);
+    const stats = manager.stats;
+    console.clear();
+    console.log("==========================================");
+    console.log("      VESPER OPERATIONS DASHBOARD         ");
+    console.log("==========================================\n");
+    const prometheus = stats.getPrometheusMetrics();
+    const summary = stats.getStats();
+    if (Object.keys(summary).length === 0) {
+        console.log("No metrics recorded yet. Process some jobs to see data.");
+    }
+    else {
+        console.log("--- SYSTEM METRICS (JSON) ---");
+        console.log(JSON.stringify(summary, null, 2));
+        console.log("\n--- PROMETHEUS EXPORT (RAW) ---");
+        console.log(prometheus);
+    }
+    console.log("\n==========================================");
+    console.log("  Press Ctrl+C to exit dashboard loop     ");
+    console.log("==========================================");
+    store.close();
+}
+// Simple loop for "real-time" feel (simulated)
+console.log("Starting Dashboard...");
+showDashboard();
+setInterval(showDashboard, 5000);

package/build/scripts/scrape-metadata.js

@@ -0,0 +1,100 @@
+import { HuggingFaceScraper } from "../metadata/scraper.js";
+import { KaggleMetadataScraper } from "../metadata/kaggle-scraper.js";
+import { MetadataStore } from "../metadata/store.js";
+import path from "path";
+async function main() {
+    const scraper = new HuggingFaceScraper();
+    const dbPath = path.join(process.cwd(), "data", "metadata.db");
+    const store = new MetadataStore(dbPath);
+    // Get limit from command line args or default to 100
+    let limit = 100;
+    if (process.argv[2] && !process.argv[2].startsWith("-")) {
+        limit = parseInt(process.argv[2], 10);
+        if (isNaN(limit))
+            limit = 100;
+    }
+    // Check if MVP filters should be disabled (--no-mvp flag)
+    const applyMVPFilters = !process.argv.includes("--no-mvp");
+    // Get domain filter if specified (--domain medicine, --domain healthcare, etc.)
+    const domainArgIndex = process.argv.indexOf("--domain");
+    const domainFilter = domainArgIndex !== -1 && process.argv[domainArgIndex + 1]
+        ? process.argv[domainArgIndex + 1]
+        : undefined;
+    try {
+        const datasets = [];
+        const domainMsg = domainFilter ? `, domain: ${domainFilter}` : "";
+        // 1. HuggingFace
+        const hfLimit = limit > 1000 ? limit : 1000; // Aim for at least 1k for "massive"
+        console.error(`Scraping HF: ${hfLimit} datasets with MVP filters: ${applyMVPFilters}${domainMsg}`);
+        const hfDatasets = await scraper.scrape(hfLimit, applyMVPFilters, domainFilter);
+        datasets.push(...hfDatasets);
+        // 2. Kaggle (Optional - only if credentials provided)
+        const kaggleUser = process.env.KAGGLE_USERNAME;
+        const kaggleKey = process.env.KAGGLE_KEY;
+        if (kaggleUser && kaggleKey) {
+            const kaggleLimit = Math.max(100, Math.floor(hfLimit / 4)); // Balance HF/Kaggle ratio
+            console.error(`\nScraping Kaggle: searching for "${domainFilter || 'all'}" (limit: ${kaggleLimit})`);
+            const kaggleScraper = new KaggleMetadataScraper(kaggleUser, kaggleKey);
+            // For massive scraping, we might want to iterate through multiple common search terms if no domainFilter is set
+            const searchTerms = domainFilter ? [domainFilter] : ["machine learning", "data science", "nlp", "computer vision", "healthcare"];
+            const termLimit = Math.floor(kaggleLimit / searchTerms.length);
+            for (const term of searchTerms) {
+                console.error(`[Kaggle] Fetching "${term}"...`);
+                const kaggleDatasets = await kaggleScraper.scrape(term, termLimit);
+                kaggleDatasets.forEach(d => {
+                    d.id = `kaggle:${d.id}`;
+                    if (!datasets.some(existing => existing.id === d.id)) {
+                        datasets.push(d);
+                    }
+                });
+            }
+        }
+        else {
+            console.error("\n[Kaggle] Skipping (KAGGLE_USERNAME/KAGGLE_KEY not set).");
+        }
+        console.error(`\nTotal Scraped: ${datasets.length} datasets.`);
+        let saved = 0;
+        store.beginTransaction(); // Performance optimization for large batch
+        try {
+            for (const ds of datasets) {
+                store.saveDataset(ds);
+                saved++;
+                if (saved % 500 === 0)
+                    console.error(`[DB] Saved ${saved} records...`);
+            }
+            store.commit();
+        }
+        catch (e) {
+            store.rollback();
+            throw e;
+        }
+        console.error(`Successfully saved ${saved} datasets to MetadataStore.`);
+        console.error(`\nSummary:`);
+        console.error(`  - Total examples: ${datasets.reduce((sum, d) => sum + d.total_examples, 0).toLocaleString()}`);
+        console.error(`  - Safe sources: ${datasets.filter(d => d.is_safe_source).length}`);
+        console.error(`  - Structured datasets: ${datasets.filter(d => d.is_structured).length}`);
+        console.error(`  - Permissive licenses: ${datasets.filter(d => d.license.category === "safe").length}`);
+        // Show domain distribution
+        const domainCounts = new Map();
+        datasets.forEach(d => {
+            const domain = d.domain || "unknown";
+            domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
+        });
+        if (domainCounts.size > 0) {
+            console.error(`  - Domains:`);
+            Array.from(domainCounts.entries())
+                .sort((a, b) => b[1] - a[1])
+                .forEach(([domain, count]) => {
+                console.error(`    ${domain}: ${count}`);
+            });
+        }
+    }
+    catch (error) {
+        console.error("Scraping failed:", error);
+        process.exit(1);
+    }
+    finally {
+        store.close();
+    }
+}
+main();

package/build/scripts/search-cli.js

@@ -0,0 +1,26 @@
+import path from "path";
+import { MetadataStore } from "../metadata/store.js";
+import { VectorStore } from "../search/vector-store.js";
+import { Embedder } from "../search/embedder.js";
+import { SearchEngine } from "../search/engine.js";
+const query = process.argv[2];
+if (!query) {
+    console.error("Usage: npx tsx src/scripts/search-cli.ts \"your query\"");
+    process.exit(1);
+}
+const dbPath = path.join(process.cwd(), "data", "metadata.db");
+const vectorPath = path.join(process.cwd(), "data", "vectors.json");
+const metadataStore = new MetadataStore(dbPath);
+const vectorStore = new VectorStore(vectorPath);
+const embedder = Embedder.getInstance();
+const searchEngine = new SearchEngine(metadataStore, vectorStore, embedder);
+async function run() {
+    console.error(`Searching for: "${query}"...`);
+    const results = await searchEngine.search(query, { limit: 5, safeOnly: true });
+    if (results.length === 0) {
+        console.log("No results found.");
+        return;
+    }
+    console.log(JSON.stringify(results, null, 2));
+}
+run().catch(console.error);

package/build/scripts/test-bias.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 Bias Analysis Test ===\n");
+    const analyzer = new QualityAnalyzer();
+    const testFile = path.join(process.cwd(), "test_bias.csv");
+    // Create a CSV with severe class imbalance
+    // 'label': 90% 'A', 10% 'B' -> Should trigger warning
+    // 'gender': 50/50 -> No warning
+    let csvContent = "id,gender,label\n";
+    for (let i = 0; i < 95; i++)
+        csvContent += `${i},M,A\n`;
+    for (let i = 95; i < 100; i++)
+        csvContent += `${i},F,B\n`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created test file: ${testFile}`);
+    console.log("Expectations:");
+    console.log("  - Should warn about 'Severe imbalance' in 'label' column (95% A)");
+    console.log("  - Should NOT warn about 'gender' (skewed but just a test sample)");
+    try {
+        console.log("\nRunning analyzer...");
+        const report = await analyzer.analyze(testFile);
+        console.log("\n=== Bias Report ===");
+        if (report.class_imbalance_warnings && report.class_imbalance_warnings.length > 0) {
+            report.class_imbalance_warnings.forEach(w => console.log(`[!] ${w}`));
+        }
+        else {
+            console.log("No bias detected.");
+        }
+        const labelWarning = report.class_imbalance_warnings?.find(w => w.includes("'label'"));
+        if (labelWarning) {
+            console.log("\nTest passed! Detected imbalance.");
+        }
+        else {
+            console.error("\nTest failed! Did not detect imbalance.");
+        }
+        // Cleanup
+        fs.unlinkSync(testFile);
+    }
+    catch (error) {
+        console.error("\nTest failed:", error);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-caching.js

@@ -0,0 +1,51 @@
+import { MockRedisProvider, CacheService } from "../cache/service.js";
+import { CDNService } from "../cache/cdn.js";
+import { CleaningPlanner } from "../cleaning/planner.js";
+async function runTest() {
+    console.log("--- Initializing Caching Layer Test ---");
+    const cacheProvider = new MockRedisProvider();
+    const cache = new CacheService(cacheProvider);
+    const planner = new CleaningPlanner(cache);
+    const cdn = new CDNService("data/cdn_mock", "https://cdn.vesper.ai");
+    const dsId = "test/cache-dataset";
+    const mockReport = {
+        row_count: 1000,
+        column_count: 2,
+        duplicate_rows: 5,
+        duplicate_percentage: 0.5,
+        columns: [
+            { name: "col1", type: "Utf8", inferred_type: "String", missing_count: 0, missing_percentage: 0, unique_count: 1000, is_constant: false, is_mixed_type: false }
+        ],
+        warnings: [],
+        schema_warnings: [],
+        overall_score: 80
+    };
+    // 1. Test Planning Cache
+    console.log("\n--- Testing Cleaning Plan Cache ---");
+    console.log("First Run (Cache Miss)...");
+    const start1 = Date.now();
+    await planner.generatePlan(dsId, mockReport);
+    console.log(`First run took ${Date.now() - start1}ms`);
+    console.log("Second Run (Cache Hit)...");
+    const start2 = Date.now();
+    await planner.generatePlan(dsId, mockReport);
+    console.log(`Second run took ${Date.now() - start2}ms (Expected to be near 0ms)`);
+    // 2. Test TTL / Hash mismatch
+    console.log("\n--- Testing Cache Sensitivity (Config Change) ---");
+    console.log("Running with a ruleSet (New Cache Key)...");
+    const start3 = Date.now();
+    await planner.generatePlan(dsId, mockReport, { id: "rules-1", name: "Custom", rules: [] });
+    console.log(`Config change run took ${Date.now() - start3}ms (Cache Miss)`);
+    // 3. Test CDN Upload
+    console.log("\n--- Testing CDN Mock ---");
+    const reportContent = JSON.stringify(mockReport, null, 2);
+    const url = await cdn.upload("report_latest.json", reportContent);
+    console.log(`Report uploaded to CDN: ${url}`);
+    if (url.startsWith("https://cdn.vesper.ai")) {
+        console.log("\n✅ Success: Caching and CDN layers verified.");
+    }
+    else {
+        console.error("\n❌ Failure: CDN URL generation mismatch.");
+    }
+}
+runTest().catch(console.error);

package/build/scripts/test-cleaning.js

@@ -0,0 +1,76 @@
+import { DataCleaner } from "../cleaning/cleaner.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Auto-Cleaning Pipeline Test ===\n");
+    const cleaner = new DataCleaner();
+    const testFile = path.join(process.cwd(), "test_cleaning.csv");
+    // Create Dirty Data
+    // - id: Duplicate rows (1)
+    // - age: Missing values, Outlier (200), Wrong Type ("thirty")
+    // - score: Good float
+    // - unnecessary: Column to drop
+    const csvContent = `id,age,score,unnecessary
+1,25,88.5,trash
+2,,92.0,trash
+3,200,15.0,trash
+1,25,88.5,trash
+4,"30",80.0,trash`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created dirty file: ${testFile}`);
+    // Define Cleaning Plan
+    const ops = [
+        {
+            type: "DropColumns",
+            params: { columns: ["unnecessary"] },
+            reason: "Not useful"
+        },
+        {
+            type: "RemoveDuplicates",
+            params: {},
+            reason: "Duplicate rows"
+        },
+        {
+            type: "FillMissing",
+            params: { column: "age", method: "constant", value: 0 },
+            reason: "Impute missing age"
+        },
+        // Note: Polars can't easily fix "thirty" to 30 automatically without specific logic, 
+        // so we just cast what we can. "30" string -> 30 int works.
+        {
+            type: "FixTypes",
+            params: { column: "age", type: "float" },
+            reason: "Convert age to number"
+        },
+        {
+            type: "RemoveOutliers",
+            params: { column: "age", method: "iqr", threshold: 1.5 },
+            reason: "Remove age > 100"
+        }
+    ];
+    try {
+        console.log("Executing cleaning plan...");
+        const result = await cleaner.clean(testFile, ops);
+        console.log("\n=== Cleaning Result ===");
+        console.log(`Success: ${result.success}`);
+        console.log(`Output: ${result.output_path || "None"}`);
+        console.log(`Rows Affected: ${result.rows_affected}`);
+        console.log("\nLogs:");
+        result.logs.forEach(l => console.log(`  - ${l}`));
+        // Validate Output File Exists
+        if (fs.existsSync(result.output_path)) {
+            console.log("\nConverted file created successfully.");
+            // Cleanup
+            fs.unlinkSync(testFile);
+            fs.unlinkSync(result.output_path);
+            console.log("Test passed!");
+        }
+        else {
+            console.error("\nTest failed! Output file missing.");
+        }
+    }
+    catch (error) {
+        console.error("\nTest failed:", error);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-cloud-storage.js

@@ -0,0 +1,48 @@
+import { StorageManager } from "../cloud/storage-manager.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Cloud Storage Test ===\n");
+    const vaultDir = path.join(process.cwd(), "test_vault");
+    const adapter = StorageManager.createAdapter({
+        type: "local",
+        options: { basePath: vaultDir }
+    });
+    const testFile = "test_upload.txt";
+    fs.writeFileSync(testFile, "Hello Cloud Storage!");
+    try {
+        console.log("Testing upload...");
+        const remotePath = "datasets/v1/test.txt";
+        const url = await adapter.upload(testFile, remotePath);
+        console.log("Upload URL:", url);
+        const expectedFile = path.join(vaultDir, remotePath);
+        if (fs.existsSync(expectedFile)) {
+            console.log("PASS: File successfully uploaded to local vault.");
+            const content = fs.readFileSync(expectedFile, "utf8");
+            if (content === "Hello Cloud Storage!") {
+                console.log("PASS: Content integrity verified.");
+            }
+        }
+        else {
+            console.error("FAIL: 0Uploaded file not found in vault.");
+        }
+        console.log("\nTesting signed URL...");
+        const signedUrl = await adapter.getSignedUrl(remotePath);
+        console.log("Signed URL:", signedUrl);
+        console.log("\nTesting deletion...");
+        await adapter.delete(remotePath);
+        if (!fs.existsSync(expectedFile)) {
+            console.log("PASS: File successfully deleted from vault.");
+        }
+    }
+    catch (e) {
+        console.error("FAIL: Cloud storage test failed:", e);
+    }
+    finally {
+        if (fs.existsSync(testFile))
+            fs.unlinkSync(testFile);
+        if (fs.existsSync(vaultDir))
+            fs.rmSync(vaultDir, { recursive: true, force: true });
+    }
+}
+main().catch(console.error);