@vespermcp/mcp-server 1.0.0

package/build/scripts/test-unified-quality.js

@@ -0,0 +1,86 @@
+import { QualityOrchestrator } from "../quality/quality-orchestrator.js";
+import path from "path";
+import fs from "fs";
+import { execSync } from "child_process";
+async function runTest() {
+    console.log("--- Testing Unified Quality Report ---");
+    const projectRoot = path.resolve(".");
+    const orchestrator = new QualityOrchestrator(projectRoot);
+    // Create a mixed dataset directory
+    const testDataDir = path.join(projectRoot, "data", "test-unified");
+    if (!fs.existsSync(testDataDir))
+        fs.mkdirSync(testDataDir, { recursive: true });
+    // 1. Create a CSV file (text modality)
+    const csvPath = path.join(testDataDir, "data.csv");
+    fs.writeFileSync(csvPath, "id,name,value\\n1,Alice,10\\n2,Bob,20\\n3,Charlie,30\\n");
+    // 2. Create a test image (using Python)
+    const imagePath = path.join(testDataDir, "test_image.png");
+    const pythonScript = `
+import numpy as np
+from PIL import Image
+img = Image.fromarray(np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8))
+img.save('${imagePath.replace(/\\/g, "\\\\")}')
+    `;
+    fs.writeFileSync(path.join(testDataDir, "gen_image.py"), pythonScript);
+    try {
+        execSync(`python "${path.join(testDataDir, "gen_image.py")}"`);
+    }
+    catch (e) {
+        console.log("⚠️  Could not generate image. Skipping image modality.");
+    }
+    // 3. Create a test audio file (using Python)
+    const audioPath = path.join(testDataDir, "test_audio.wav");
+    const audioScript = `
+import numpy as np
+import soundfile as sf
+sample_rate = 44100
+duration = 1.0
+frequency = 440.0
+t = np.linspace(0, duration, int(sample_rate * duration))
+audio = 0.5 * np.sin(2 * np.pi * frequency * t)
+sf.write('${audioPath.replace(/\\/g, "\\\\")}', audio, sample_rate)
+    `;
+    fs.writeFileSync(path.join(testDataDir, "gen_audio.py"), audioScript);
+    try {
+        execSync(`python "${path.join(testDataDir, "gen_audio.py")}"`);
+    }
+    catch (e) {
+        console.log("⚠️  Could not generate audio. Skipping audio modality.");
+    }
+    // 4. Run Unified Quality Analysis
+    console.log(`\\nAnalyzing multimodal dataset at ${testDataDir}...`);
+    try {
+        const report = await orchestrator.generateReport("test-unified-dataset", testDataDir, null);
+        console.log("\\n📊 Unified Quality Report:");
+        console.log(`- Dataset ID: ${report.dataset_id}`);
+        console.log(`- Modalities: ${report.modalities.join(", ")}`);
+        console.log(`- Overall Quality Score: ${report.overall_quality_score}/100`);
+        if (report.image_quality) {
+            console.log(`\\n🖼️  Image Quality:`);
+            console.log(`  - Total Images: ${report.image_quality.total_images}`);
+            console.log(`  - Avg Resolution: ${report.image_quality.avg_resolution}`);
+        }
+        if (report.audio_quality) {
+            console.log(`\\n🎵 Audio Quality:`);
+            console.log(`  - Total Files: ${report.audio_quality.total_files}`);
+            console.log(`  - Avg Duration: ${report.audio_quality.avg_duration.toFixed(1)}s`);
+        }
+        console.log(`\\n💡 Recommendations:`);
+        report.recommendations.forEach(rec => console.log(`  - ${rec}`));
+        // Verify modalities detected
+        const hasText = report.modalities.includes("text");
+        const hasImage = report.modalities.includes("image");
+        const hasAudio = report.modalities.includes("audio");
+        if (hasText && (hasImage || hasAudio) && report.overall_quality_score > 0) {
+            console.log("\\nVERIFICATION_STATUS: ✅ PASS");
+        }
+        else {
+            console.log("\\nVERIFICATION_STATUS: ⚠️  PARTIAL (Some modalities missing)");
+        }
+    }
+    catch (e) {
+        console.error(`Analysis failed: ${e.message}`);
+        console.log("\\nVERIFICATION_STATUS: ❌ FAIL");
+    }
+}
+runTest().catch(console.error);

package/build/search/embedder.js

@@ -0,0 +1,34 @@
+import { pipeline, env } from "@xenova/transformers";
+// Disable local model check to ensure it downloads if not found
+env.allowLocalModels = false;
+env.useBrowserCache = false;
+export class Embedder {
+    static instance;
+    extractor = null;
+    modelName = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+    constructor() { }
+    static getInstance() {
+        if (!Embedder.instance) {
+            Embedder.instance = new Embedder();
+        }
+        return Embedder.instance;
+    }
+    async init() {
+        if (this.extractor)
+            return;
+        console.error(`Loading embedding model: ${this.modelName}...`);
+        this.extractor = await pipeline("feature-extraction", this.modelName);
+        console.error("Embedding model loaded successfully.");
+    }
+    async embed(text) {
+        if (!this.extractor) {
+            await this.init();
+        }
+        const result = await this.extractor(text, {
+            pooling: "mean",
+            normalize: true,
+        });
+        // result.data is already a Float32Array in Xenova/transformers
+        return result.data;
+    }
+}

package/build/search/engine.js

@@ -0,0 +1,129 @@
+import { JITOrchestrator } from "./jit-orchestrator.js";
+import fs from "fs";
+function log(msg) {
+    fs.appendFileSync("debug.log", new Date().toISOString() + " " + msg + "\n");
+}
+export class SearchEngine {
+    metadataStore;
+    vectorStore;
+    embedder;
+    jitOrchestrator;
+    constructor(metadataStore, vectorStore, embedder) {
+        this.metadataStore = metadataStore;
+        this.vectorStore = vectorStore;
+        this.embedder = embedder;
+        this.jitOrchestrator = new JITOrchestrator(metadataStore, vectorStore, embedder);
+    }
+    async search(query, options = {}) {
+        const limit = options.limit || 5;
+        const enableJIT = options.enableJIT !== false; // Default: true
+        log(`Search request: "${query}" Limit=${limit} Safe=${options.safeOnly} JIT=${enableJIT}`);
+        // 1. Perform local search
+        const localResults = await this.localSearch(query, options);
+        // 2. Check if JIT should be triggered
+        const shouldTrigger = enableJIT && this.shouldTriggerJIT(localResults, query);
+        if (!shouldTrigger) {
+            log(`JIT not triggered. Returning ${localResults.length} local results`);
+            return localResults;
+        }
+        // 3. Trigger JIT fallback
+        console.error(`\nWARNING: Low confidence results (${localResults.length} found, top score: ${localResults[0]?.relevance_score || 0})`);
+        await this.jitOrchestrator.fetchAndIngest(query, 10);
+        // 4. Re-run local search with updated index
+        console.error(`Re-searching with updated library...`);
+        const enhancedResults = await this.localSearch(query, options);
+        const newCount = enhancedResults.length - localResults.length;
+        if (newCount > 0) {
+            console.error(`Found ${newCount} additional results\n`);
+        }
+        return enhancedResults;
+    }
+    /**
+     * Perform hybrid search (Vector + Lexical + Penalties)
+     */
+    async localSearch(query, options) {
+        const limit = options.limit || 5;
+        // 1. Parse Query
+        const words = query.toLowerCase().split(/\s+/);
+        const positiveKeywords = words.filter(w => !w.startsWith("-") && w.length > 2);
+        const negativeKeywords = words.filter(w => w.startsWith("-")).map(w => w.slice(1));
+        // Automatic Penalty Detection: Is this a "Finance" query without "Crypto" mentioned?
+        const financeTerms = ["financial", "finance", "banking", "economy", "stock", "loan", "forecasting", "bank"];
+        const isFinanceQuery = positiveKeywords.some(w => financeTerms.includes(w));
+        const mentionsCrypto = query.toLowerCase().includes("crypto") || query.toLowerCase().includes("bitcoin");
+        // 2. Get query vector
+        const queryVector = await this.embedder.embed(query);
+        log(`Vector generated, length=${queryVector.length}`);
+        // 3. Search in vector store (fetch more candidates for reranking)
+        const matches = this.vectorStore.search(queryVector, 40);
+        log(`Vector search found ${matches.length} matches`);
+        // 4. Score and filter candidates
+        const results = [];
+        for (const match of matches) {
+            const metadata = this.metadataStore.getDataset(match.id);
+            if (!metadata)
+                continue;
+            // Filter: Safe only
+            if (options.safeOnly && metadata.license.category === "restricted")
+                continue;
+            const text = `${metadata.name} ${metadata.description} ${metadata.tags.join(" ")}`.toLowerCase();
+            // Filter: Explicit Negative Keywords
+            if (negativeKeywords.some(neg => text.includes(neg))) {
+                log(`Negative penalty: Dropped ${match.id} due to keyword match`);
+                continue;
+            }
+            // A. Vector Score (0.0 to 1.0)
+            const vectorScore = match.score;
+            // B. Lexical Score (Keyword Match)
+            let lexicalScore = 0;
+            if (positiveKeywords.length > 0) {
+                const matchesCount = positiveKeywords.filter(kw => text.includes(kw)).length;
+                lexicalScore = matchesCount / positiveKeywords.length;
+            }
+            // C. Penalties
+            let penalty = 0;
+            // Penalty: Domain Drift (Finance vs Crypto)
+            // If user asks for finance but NOT crypto, and the result is crypto, penalize heavily
+            if (isFinanceQuery && !mentionsCrypto) {
+                const isCryptoResult = text.includes("crypto") || text.includes("bitcoin") || text.includes("ethereum") || text.includes("blockchain");
+                if (isCryptoResult) {
+                    log(`Penalty applied: Crypto result in Finance query for ${match.id}`);
+                    penalty += 0.4; // Massive penalty
+                }
+            }
+            // Penalty: Weak Lexical Match
+            // If it's a "semantic vibe" match but has ZERO matching keywords from the query
+            if (lexicalScore === 0 && positiveKeywords.length > 1) {
+                penalty += 0.2;
+            }
+            // Final Combined Score
+            // 70% Vector, 30% Lexical, minus Penalties
+            const finalScore = (vectorScore * 0.7) + (lexicalScore * 0.3) - penalty;
+            metadata.relevance_score = Math.round(finalScore * 100) / 100;
+            metadata.vector_score = Math.round(vectorScore * 100) / 100;
+            metadata.lexical_score = Math.round(lexicalScore * 100) / 100;
+            results.push(metadata);
+        }
+        // Sort by final score and limit
+        return results
+            .sort((a, b) => b.relevance_score - a.relevance_score)
+            .slice(0, limit);
+    }
+    /**
+     * Determine if JIT should be triggered
+     */
+    shouldTriggerJIT(results, query) {
+        // Condition 1: Very few results
+        if (results.length < 3) {
+            log(`JIT trigger: Only ${results.length} results found`);
+            return true;
+        }
+        // Condition 2: Low confidence (top result has low similarity)
+        const topScore = results[0]?.relevance_score || 0;
+        if (topScore < 0.60) {
+            log(`JIT trigger: Low confidence (top score: ${topScore})`);
+            return true;
+        }
+        return false;
+    }
+}

package/build/search/jit-orchestrator.js

@@ -0,0 +1,232 @@
+import { HuggingFaceScraper } from "../metadata/scraper.js";
+import { KaggleMetadataScraper } from "../metadata/kaggle-scraper.js";
+import { UCIScraper } from "../metadata/uci-scraper.js";
+import { GitHubScraper } from "../metadata/github-scraper.js";
+import { WorldBankScraper, NASAScraper } from "../metadata/institutional-scrapers.js";
+/**
+ * Just-In-Time Orchestrator
+ * Automatically fetches and indexes new datasets when local search is insufficient
+ */
+export class JITOrchestrator {
+    metadataStore;
+    vectorStore;
+    embedder;
+    lastTriggerTime = new Map();
+    RATE_LIMIT_MS = 30000; // 30 seconds between triggers for same query
+    constructor(metadataStore, vectorStore, embedder) {
+        this.metadataStore = metadataStore;
+        this.vectorStore = vectorStore;
+        this.embedder = embedder;
+    }
+    /**
+     * Check if JIT should be triggered based on rate limiting
+     */
+    canTrigger(query) {
+        const lastTrigger = this.lastTriggerTime.get(query);
+        if (!lastTrigger)
+            return true;
+        const elapsed = Date.now() - lastTrigger;
+        return elapsed > this.RATE_LIMIT_MS;
+    }
+    /**
+     * Main JIT workflow: fetch, save, index, return new datasets
+     */
+    async fetchAndIngest(query, limit = 10) {
+        // Rate limiting check
+        if (!this.canTrigger(query)) {
+            console.error(`[JIT] Rate limit: Query "${query}" triggered too recently`);
+            return [];
+        }
+        console.error(`\n[JIT] Searching live sources for: "${query}"`);
+        this.lastTriggerTime.set(query, Date.now());
+        const newDatasets = [];
+        const existingIds = new Set();
+        try {
+            // Get existing dataset IDs to avoid duplicates
+            const existing = this.metadataStore.getAllDatasets();
+            existing.forEach(ds => existingIds.add(ds.id));
+            // 1. Scrape HuggingFace
+            const hfResults = await this.scrapeHuggingFace(query, limit);
+            console.error(`  HuggingFace: Found ${hfResults.length} datasets`);
+            for (const ds of hfResults) {
+                if (!existingIds.has(ds.id)) {
+                    newDatasets.push(ds);
+                    existingIds.add(ds.id);
+                }
+            }
+            // 2. Scrape Kaggle (if credentials available)
+            const kaggleUser = process.env.KAGGLE_USERNAME;
+            const kaggleKey = process.env.KAGGLE_KEY;
+            if (kaggleUser && kaggleKey) {
+                const kaggleResults = await this.scrapeKaggle(query, Math.floor(limit / 2));
+                console.error(`  Kaggle: Found ${kaggleResults.length} datasets`);
+                for (const ds of kaggleResults) {
+                    ds.id = `kaggle:${ds.id}`;
+                    if (!existingIds.has(ds.id)) {
+                        newDatasets.push(ds);
+                        existingIds.add(ds.id);
+                    }
+                }
+            }
+            // 3. Scrape UCI
+            const uciResults = await this.scrapeUCI(query, Math.floor(limit / 2));
+            console.error(`  UCI: Found ${uciResults.length} datasets`);
+            for (const ds of uciResults) {
+                if (!existingIds.has(ds.id)) {
+                    newDatasets.push(ds);
+                    existingIds.add(ds.id);
+                }
+            }
+            // 4. Scrape GitHub
+            const githubResults = await this.scrapeGitHub(query, Math.floor(limit / 2));
+            console.error(`  GitHub: Found ${githubResults.length} datasets`);
+            for (const ds of githubResults) {
+                if (!existingIds.has(ds.id)) {
+                    newDatasets.push(ds);
+                    existingIds.add(ds.id);
+                }
+            }
+            // 5. Scrape World Bank
+            const wbResults = await this.scrapeWorldBank(query, Math.floor(limit / 2));
+            console.error(`  World Bank: Found ${wbResults.length} datasets`);
+            for (const ds of wbResults) {
+                if (!existingIds.has(ds.id)) {
+                    newDatasets.push(ds);
+                    existingIds.add(ds.id);
+                }
+            }
+            // 6. Scrape NASA
+            const nasaResults = await this.scrapeNASA(query, Math.floor(limit / 2));
+            console.error(`  NASA: Found ${nasaResults.length} datasets`);
+            for (const ds of nasaResults) {
+                if (!existingIds.has(ds.id)) {
+                    newDatasets.push(ds);
+                    existingIds.add(ds.id);
+                }
+            }
+            // 3. Save and index new datasets
+            if (newDatasets.length > 0) {
+                await this.saveAndIndex(newDatasets);
+                console.error(`[JIT] Indexed ${newDatasets.length} new datasets`);
+            }
+            else {
+                console.error(`  [JIT] No new datasets found`);
+            }
+            return newDatasets;
+        }
+        catch (error) {
+            console.error(`ERROR [JIT] Error during fetch and ingest:`, error.message);
+            return [];
+        }
+    }
+    /**
+     * Scrape HuggingFace with free-text search
+     */
+    async scrapeHuggingFace(query, limit) {
+        const scraper = new HuggingFaceScraper();
+        try {
+            // Use the query as a domain filter for now
+            // In the future, we can add a freeTextSearch parameter to the scraper
+            return await scraper.scrape(limit, true, query);
+        }
+        catch (error) {
+            console.error(`  ERROR: HuggingFace scrape failed: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Scrape Kaggle with search query
+     */
+    async scrapeKaggle(query, limit) {
+        const kaggleUser = process.env.KAGGLE_USERNAME;
+        const kaggleKey = process.env.KAGGLE_KEY;
+        if (!kaggleUser || !kaggleKey) {
+            return [];
+        }
+        try {
+            const scraper = new KaggleMetadataScraper(kaggleUser, kaggleKey);
+            return await scraper.scrape(query, limit);
+        }
+        catch (error) {
+            console.error(`  ERROR: Kaggle scrape failed: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Scrape UCI
+     */
+    async scrapeUCI(query, limit) {
+        const scraper = new UCIScraper();
+        try {
+            return await scraper.scrape(query, limit);
+        }
+        catch (error) {
+            console.error(`  ERROR: UCI scrape failed: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Scrape GitHub
+     */
+    async scrapeGitHub(query, limit) {
+        const scraper = new GitHubScraper();
+        try {
+            return await scraper.scrape(query, limit);
+        }
+        catch (error) {
+            console.error(`  ERROR: GitHub scrape failed: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Scrape World Bank
+     */
+    async scrapeWorldBank(query, limit) {
+        const scraper = new WorldBankScraper();
+        try {
+            return await scraper.scrape(query, limit);
+        }
+        catch (error) {
+            console.error(`  ERROR: World Bank scrape failed: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Scrape NASA
+     */
+    async scrapeNASA(query, limit) {
+        const scraper = new NASAScraper();
+        try {
+            return await scraper.scrape(query, limit);
+        }
+        catch (error) {
+            console.error(`  ERROR: NASA scrape failed: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Save datasets to DB and generate embeddings
+     */
+    async saveAndIndex(datasets) {
+        // 1. Save to database
+        this.metadataStore.beginTransaction();
+        try {
+            for (const ds of datasets) {
+                this.metadataStore.saveDataset(ds);
+            }
+            this.metadataStore.commit();
+        }
+        catch (e) {
+            this.metadataStore.rollback();
+            throw e;
+        }
+        // 2. Generate embeddings and update vector store
+        for (const ds of datasets) {
+            const text = `${ds.name} ${ds.description} ${ds.tags.join(" ")}`;
+            const vector = await this.embedder.embed(text);
+            this.vectorStore.add(ds.id, vector);
+        }
+        // 3. Persist vector store to disk
+        this.vectorStore.save();
+    }
+}

package/build/search/vector-store.js

@@ -0,0 +1,105 @@
+import fs from "fs";
+import path from "path";
+export class VectorStore {
+    idToVector = new Map();
+    filePath;
+    binPath;
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.binPath = filePath.replace(".json", ".bin");
+        this.load();
+    }
+    load() {
+        if (fs.existsSync(this.filePath) && fs.existsSync(this.binPath)) {
+            try {
+                const metadata = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+                const buffer = fs.readFileSync(this.binPath);
+                const ids = metadata.ids;
+                const dim = metadata.dimension;
+                for (let i = 0; i < ids.length; i++) {
+                    const start = i * dim * 4;
+                    const vector = new Float32Array(buffer.buffer, buffer.byteOffset + start, dim);
+                    this.idToVector.set(ids[i], new Float32Array(vector)); // Copy to ensure independence
+                }
+                console.error(`Loaded ${this.idToVector.size} vectors from binary store`);
+            }
+            catch (err) {
+                console.error("Failed to load vector store:", err);
+                this.idToVector.clear();
+            }
+        }
+        else if (fs.existsSync(this.filePath)) {
+            // Migration from old JSON format
+            try {
+                const data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+                if (Array.isArray(data)) {
+                    for (const entry of data) {
+                        this.idToVector.set(entry.id, new Float32Array(entry.vector));
+                    }
+                    console.error(`Migrated ${this.idToVector.size} vectors from legacy JSON`);
+                    this.save(); // Convert to binary immediately
+                }
+            }
+            catch (err) {
+                console.error("Migration failed:", err);
+            }
+        }
+    }
+    save() {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const ids = Array.from(this.idToVector.keys());
+        if (ids.length === 0)
+            return;
+        const dim = this.idToVector.get(ids[0]).length;
+        const buffer = Buffer.alloc(ids.length * dim * 4);
+        for (let i = 0; i < ids.length; i++) {
+            const vector = this.idToVector.get(ids[i]);
+            const byteOffset = i * dim * 4;
+            for (let j = 0; j < dim; j++) {
+                buffer.writeFloatLE(vector[j], byteOffset + j * 4);
+            }
+        }
+        fs.writeFileSync(this.binPath, buffer);
+        fs.writeFileSync(this.filePath, JSON.stringify({
+            ids,
+            dimension: dim,
+            count: ids.length,
+            updatedAt: new Date().toISOString()
+        }, null, 2));
+        console.error(`Saved ${ids.length} vectors to binary store (${this.binPath})`);
+    }
+    add(id, vector) {
+        this.idToVector.set(id, vector instanceof Float32Array ? vector : new Float32Array(vector));
+    }
+    search(queryVector, limit = 10) {
+        const q = queryVector instanceof Float32Array ? queryVector : new Float32Array(queryVector);
+        const results = [];
+        for (const [id, v] of this.idToVector.entries()) {
+            results.push({
+                id,
+                score: this.cosineSimilarity(q, v)
+            });
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    cosineSimilarity(v1, v2) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < v1.length; i++) {
+            dotProduct += v1[i] * v2[i];
+            normA += v1[i] * v1[i];
+            normB += v2[i] * v2[i];
+        }
+        const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+        return magnitude === 0 ? 0 : dotProduct / magnitude;
+    }
+    getAllIds() {
+        return Array.from(this.idToVector.keys());
+    }
+}

package/build/splitting/splitter.js

@@ -0,0 +1,57 @@
+import { spawn } from "child_process";
+import path from "path";
+export class DataSplitter {
+    pythonPath = "python";
+    scriptPath;
+    constructor(projectRoot = process.cwd()) {
+        this.scriptPath = path.join(projectRoot, "src", "python", "splitter_engine.py");
+    }
+    /**
+     * Splits a dataset into Train/Val/Test sets based on config
+     */
+    async split(filePath, config) {
+        return this.runPython("split", [filePath, JSON.stringify(config)]);
+    }
+    /**
+     * Validates a split for leakage and distribution
+     */
+    async validate(paths, options) {
+        const config = {
+            paths,
+            id_column: options?.id_column,
+            target_column: options?.target_column
+        };
+        return this.runPython("validate", [JSON.stringify(config)]);
+    }
+    async runPython(action, args) {
+        return new Promise((resolve, reject) => {
+            const process = spawn(this.pythonPath, [this.scriptPath, action, ...args]);
+            let stdout = "";
+            let stderr = "";
+            process.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            process.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+            process.on("close", (code) => {
+                if (code !== 0) {
+                    reject(new Error(`Data Splitter (${action}) failed: ${stderr}`));
+                    return;
+                }
+                try {
+                    const result = JSON.parse(stdout);
+                    if (result.error) {
+                        reject(new Error(result.error));
+                    }
+                    else {
+                        resolve(result);
+                    }
+                }
+                catch (e) {
+                    reject(new Error(`Failed to parse output: ${stdout}`));
+                }
+            });
+        });
+    }
+}

package/build/splitting/types.js

@@ -0,0 +1 @@
+export {};