vesper-wizard 2.0.5 → 2.0.6

package/build/tools/formatter.js

@@ -0,0 +1,251 @@
+/**
+ * Format job status for visual representation
+ */
+export function formatJobStatus(job) {
+    const statusMap = {
+        "pending": "PENDING",
+        "queued": "QUEUED",
+        "running": "RUNNING",
+        "completed": "COMPLETED",
+        "failed": "FAILED",
+        "retrying": "RETRYING"
+    };
+    const statusText = statusMap[job.status] || "UNKNOWN";
+    const barWidth = 20;
+    const filledWidth = Math.round((job.progress / 100) * barWidth);
+    const emptyWidth = barWidth - filledWidth;
+    const bar = "█".repeat(filledWidth) + "░".repeat(emptyWidth);
+    let output = `═ Job Status: ${job.type.toUpperCase()} ═\n`;
+    output += `ID: ${job.id}\n`;
+    output += `Status: ${statusText}\n`;
+    output += `Progress: ${bar} ${job.progress}%\n`;
+    output += `Activity: ${job.status_text}\n`;
+    if (job.status === "running" || job.status === "retrying" || job.status === "queued" || job.status === "pending") {
+        output += `Polling hint: check again in 5-10 seconds.\n`;
+    }
+    else {
+        output += `Polling hint: no further polling required.\n`;
+    }
+    if (job.result_url) {
+        output += `\nResult: ${job.result_url}\n`;
+    }
+    if (job.error) {
+        output += `\nERROR:\n`;
+        // Format multi-line errors nicely
+        const errorLines = job.error.split('\n');
+        errorLines.forEach(line => {
+            output += `   ${line}\n`;
+        });
+        output += `\n`;
+    }
+    output += `Updated: ${new Date(job.updated_at).toLocaleTimeString()}\n`;
+    output += "═".repeat(25) + "\n";
+    return output;
+}
+/**
+ * Format dataset search results for human-readable display
+ */
+export function formatSearchResults(results) {
+    if (results.length === 0) {
+        return "No datasets found matching your query.";
+    }
+    let output = `Found ${results.length} dataset(s):\n\n`;
+    output += "═".repeat(80) + "\n\n";
+    results.forEach((ds, index) => {
+        const relevanceScore = ds.relevance_score || 0;
+        // Source badge and access level
+        const openSources = ["huggingface", "openml", "s3", "uci", "github", "worldbank", "nasa"];
+        const isOpen = openSources.includes(ds.source);
+        const sourceLabel = ds.source.charAt(0).toUpperCase() + ds.source.slice(1);
+        const accessBadge = isOpen ? "Open Access" : "Requires API Key";
+        // Safety indicator
+        let safetyIndicator = "";
+        if (ds.license.category === "safe") {
+            safetyIndicator = "Safe";
+        }
+        else if (ds.license.category === "restricted") {
+            safetyIndicator = "Restricted";
+        }
+        else {
+            safetyIndicator = "Unknown License";
+        }
+        // Header
+        output += `${index + 1}. ${ds.name}\n`;
+        output += `   Source: ${sourceLabel} | ${accessBadge} | ${safetyIndicator}\n`;
+        output += `   Relevance: ${(relevanceScore * 100).toFixed(0)}% | ID: ${ds.id}\n\n`;
+        // Description
+        if (ds.description && ds.description.length > 0) {
+            const shortDesc = ds.description.length > 200
+                ? ds.description.substring(0, 200) + "..."
+                : ds.description;
+            output += `   ${shortDesc}\n\n`;
+        }
+        // Quality warnings
+        if (ds.quality_warnings && ds.quality_warnings.length > 0) {
+            output += `   Quality Warnings:\n`;
+            ds.quality_warnings.forEach(warning => {
+                output += `      • ${warning}\n`;
+            });
+            output += "\n";
+        }
+        // Key stats
+        output += `   Stats:\n`;
+        if (ds.downloads)
+            output += `      Downloads: ${ds.downloads.toLocaleString()}\n`;
+        if (ds.likes)
+            output += `      Likes: ${ds.likes}\n`;
+        if (ds.total_examples)
+            output += `      Examples: ${ds.total_examples.toLocaleString()}\n`;
+        if (ds.total_size_mb)
+            output += `      Size: ${ds.total_size_mb} MB\n`;
+        output += `      Domain: ${ds.domain || "unknown"}\n`;
+        output += `      Task: ${ds.task || "unknown"}\n`;
+        // Data splits
+        if (ds.splits && ds.splits.length > 0) {
+            const splitNames = ds.splits.map(s => s.name).join(", ");
+            output += `      Splits: ${splitNames}\n`;
+        }
+        // License details
+        output += `\n   License: ${ds.license.id || "Unknown"}\n`;
+        if (ds.license.warnings && ds.license.warnings.length > 0) {
+            ds.license.warnings.forEach(warning => {
+                output += `      WARNING: ${warning}\n`;
+            });
+        }
+        if (ds.license.commercial_use !== undefined) {
+            output += `      Commercial use: ${ds.license.commercial_use ? "Yes" : "No"}\n`;
+        }
+        // Download link
+        output += `\n   ${ds.download_url}\n`;
+        output += "\n" + "─".repeat(80) + "\n\n";
+    });
+    return output;
+}
+/**
+ * Format detailed dataset info
+ */
+export function formatDatasetInfo(ds) {
+    let output = "";
+    // Header
+    output += "═".repeat(80) + "\n";
+    output += `${ds.name}\n`;
+    output += "═".repeat(80) + "\n\n";
+    // Source and safety
+    const openSources = ["huggingface", "openml", "s3", "uci", "github", "worldbank", "nasa"];
+    const isOpen = openSources.includes(ds.source);
+    const sourceLabel = ds.source.charAt(0).toUpperCase() + ds.source.slice(1);
+    const accessBadge = isOpen ? "Open Access" : "Requires API Key";
+    let safetyIndicator = "";
+    if (ds.license.category === "safe") {
+        safetyIndicator = "Safe for use";
+    }
+    else if (ds.license.category === "restricted") {
+        safetyIndicator = "Restricted - Review license carefully";
+    }
+    else {
+        safetyIndicator = "Unknown license - Use with caution";
+    }
+    output += `Source: ${sourceLabel} (${accessBadge})\n`;
+    output += `Safety: ${safetyIndicator}\n`;
+    output += `ID: ${ds.id}\n\n`;
+    if (!isOpen && ds.source === "kaggle") {
+        output += `NOTE: This dataset uses the Kaggle connector. Vesper can access it through server-managed credentials when configured, otherwise a Kaggle key is still required.\n\n`;
+    }
+    if (!isOpen && ds.source === "dataworld") {
+        output += `NOTE: This dataset uses the data.world connector. Vesper can access it through a server-managed token when configured.\n\n`;
+    }
+    // Description
+    if (ds.description) {
+        output += "Description:\n";
+        output += `${ds.description}\n\n`;
+    }
+    // Quality warnings
+    if (ds.quality_warnings && ds.quality_warnings.length > 0) {
+        output += "Quality Warnings:\n";
+        ds.quality_warnings.forEach(warning => {
+            output += `   • ${warning}\n`;
+        });
+        output += "\n";
+    }
+    // Metadata
+    output += "Metadata:\n";
+    output += `   Downloads: ${ds.downloads?.toLocaleString() || "N/A"}\n`;
+    output += `   Likes: ${ds.likes || 0}\n`;
+    output += `   Quality Score: ${ds.quality_score}/100\n`;
+    output += `   Domain: ${ds.domain || "unknown"}\n`;
+    output += `   Task: ${ds.task || "unknown"}\n`;
+    output += `   Languages: ${ds.languages?.join(", ") || "N/A"}\n`;
+    output += `   Last Updated: ${new Date(ds.last_updated).toLocaleDateString()}\n\n`;
+    // Data characteristics
+    output += "Data Characteristics:\n";
+    output += `   Total Examples: ${ds.total_examples?.toLocaleString() || "N/A"}\n`;
+    output += `   Total Size: ${ds.total_size_mb ? ds.total_size_mb + " MB" : "N/A"}\n`;
+    output += `   Structured: ${ds.is_structured ? "Yes" : "No"}\n`;
+    output += `   Has Target Column: ${ds.has_target_column ? "Yes" : "No"}\n`;
+    output += `   Format: ${ds.format || "N/A"}\n\n`;
+    // Splits
+    if (ds.splits && ds.splits.length > 0) {
+        output += "Data Splits:\n";
+        ds.splits.forEach(split => {
+            output += `   • ${split.name}: ${split.num_examples?.toLocaleString() || "?"} examples`;
+            if (split.size_bytes) {
+                output += ` (${(split.size_bytes / (1024 * 1024)).toFixed(2)} MB)`;
+            }
+            output += "\n";
+        });
+        output += "\n";
+    }
+    // Columns
+    if (ds.columns && ds.columns.length > 0) {
+        output += "Columns:\n";
+        ds.columns.slice(0, 10).forEach(col => {
+            const targetMarker = col.is_target ? " [TARGET]" : "";
+            output += `   • ${col.name}${targetMarker}`;
+            if (col.type)
+                output += ` (${col.type})`;
+            output += "\n";
+        });
+        if (ds.columns.length > 10) {
+            output += `   ... and ${ds.columns.length - 10} more columns\n`;
+        }
+        output += "\n";
+    }
+    // License
+    output += "License Information:\n";
+    output += `   License: ${ds.license.id || "Unknown"}\n`;
+    output += `   Category: ${ds.license.category}\n`;
+    output += `   Commercial Use: ${ds.license.commercial_use ? "Allowed" : "Not allowed"}\n`;
+    if (ds.license.warnings && ds.license.warnings.length > 0) {
+        output += `   Warnings:\n`;
+        ds.license.warnings.forEach(warning => {
+            output += `      WARNING: ${warning}\n`;
+        });
+    }
+    if (ds.license.usage_restrictions && ds.license.usage_restrictions.length > 0) {
+        output += `   Restrictions:\n`;
+        ds.license.usage_restrictions.forEach(restriction => {
+            output += `      • ${restriction}\n`;
+        });
+    }
+    output += "\n";
+    // Safety flags
+    output += "Safety Flags:\n";
+    output += `   Safe Source: ${ds.is_safe_source ? "Yes" : "No"}\n`;
+    output += `   Has Personal Data: ${ds.has_personal_data ? "Yes" : "No"}\n`;
+    output += `   Paywalled: ${ds.is_paywalled ? "Yes" : "No"}\n`;
+    output += `   Scraped Web Data: ${ds.is_scraped_web_data ? "Yes" : "No"}\n\n`;
+    // Tags
+    if (ds.tags && ds.tags.length > 0) {
+        output += "Tags:\n";
+        output += `   ${ds.tags.slice(0, 15).join(", ")}`;
+        if (ds.tags.length > 15) {
+            output += ` ... and ${ds.tags.length - 15} more`;
+        }
+        output += "\n\n";
+    }
+    // Download link
+    output += "Download:\n";
+    output += `   ${ds.download_url}\n\n`;
+    output += "═".repeat(80) + "\n";
+    return output;
+}

package/build/utils/downloader.js

@@ -0,0 +1,52 @@
+import fs from "fs";
+import { Readable } from "stream";
+import { finished } from "stream/promises";
+import { retryWithBackoff } from "../metadata/rate-limiter.js";
+export class RobustDownloader {
+    /**
+     * Downloads a file with automatic retries and resume support
+     */
+    async download(url, targetPath, options = {}) {
+        await retryWithBackoff(async () => {
+            let startByte = 0;
+            const headers = { ...(options.headers || {}) };
+            // Handle resume logic
+            if (options.resume && fs.existsSync(targetPath)) {
+                startByte = fs.statSync(targetPath).size;
+                if (startByte > 0) {
+                    headers["Range"] = `bytes=${startByte}-`;
+                    console.error(`[Downloader] Resuming from byte ${startByte}`);
+                }
+            }
+            const response = await fetch(url, { headers });
+            if (response.status === 416) {
+                // Requested range not satisfiable - likely already finished
+                console.error("[Downloader] Range not satisfiable, file might be complete.");
+                return;
+            }
+            if (!response.ok && response.status !== 206) {
+                throw new Error(`Download failed: ${response.statusText} (${response.status})`);
+            }
+            const contentLength = response.headers.get("content-length");
+            const totalSize = (contentLength ? parseInt(contentLength, 10) : 0) + startByte;
+            const reader = response.body;
+            if (!reader)
+                throw new Error("Response body is empty");
+            // Open stream in append mode if resuming
+            const fileStream = fs.createWriteStream(targetPath, { flags: startByte > 0 ? "a" : "w" });
+            const nodeReadable = Readable.fromWeb(reader);
+            let downloadedBytes = startByte;
+            let lastProgressTime = 0;
+            nodeReadable.on("data", (chunk) => {
+                downloadedBytes += chunk.length;
+                // Throttle progress updates
+                const now = Date.now();
+                if (options.onProgress && (now - lastProgressTime > 500 || downloadedBytes === totalSize)) {
+                    options.onProgress(downloadedBytes, totalSize);
+                    lastProgressTime = now;
+                }
+            });
+            await finished(nodeReadable.pipe(fileStream));
+        }, { maxRetries: 5, initialDelay: 2000 });
+    }
+}

package/build/utils/selector.js

@@ -0,0 +1,69 @@
+import readline from "readline";
+export class Selector {
+    currentIndex = 0;
+    options;
+    title;
+    constructor(title, options) {
+        this.title = title;
+        this.options = options;
+    }
+    render() {
+        // Clear previous lines
+        process.stdout.write("\x1b[?25l"); // Hide cursor
+        readline.cursorTo(process.stdout, 0);
+        // Clear the lines we used before (options + title + blank line)
+        for (let i = 0; i <= this.options.length + 1; i++) {
+            readline.clearLine(process.stdout, 0);
+            process.stdout.write("\x1b[1A"); // Move up one line
+        }
+        readline.clearLine(process.stdout, 0);
+        console.log(`\n${this.title}`);
+        this.options.forEach((opt, idx) => {
+            const isCurrent = idx === this.currentIndex;
+            const checkbox = opt.selected ? "[\x1b[32mX\x1b[0m]" : "[ ]";
+            const cursor = isCurrent ? "\x1b[36m>\x1b[0m " : "  ";
+            const label = isCurrent ? `\x1b[36m${opt.name}\x1b[0m` : opt.name;
+            console.log(`${cursor}${checkbox} ${label}`);
+        });
+        console.log("\x1b[2m(Use arrows to move, Space to toggle, Enter to confirm)\x1b[0m");
+    }
+    async run() {
+        if (this.options.length === 0)
+            return [];
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        // Initial render room (print blank lines to be cleared)
+        console.log("\n".repeat(this.options.length + 1));
+        this.render();
+        return new Promise((resolve) => {
+            const handleKey = (str, key) => {
+                if (key.name === "up") {
+                    this.currentIndex = (this.currentIndex - 1 + this.options.length) % this.options.length;
+                    this.render();
+                }
+                else if (key.name === "down") {
+                    this.currentIndex = (this.currentIndex + 1) % this.options.length;
+                    this.render();
+                }
+                else if (key.name === "space") {
+                    this.options[this.currentIndex].selected = !this.options[this.currentIndex].selected;
+                    this.render();
+                }
+                else if (key.name === "return") {
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener("keypress", handleKey);
+                    process.stdout.write("\x1b[?25h"); // Show cursor
+                    console.log("");
+                    resolve(this.options.filter(o => o.selected).map(o => o.value));
+                }
+                else if (key.ctrl && key.name === "c") {
+                    process.stdin.setRawMode(false);
+                    process.exit();
+                }
+            };
+            process.stdin.on("keypress", handleKey);
+        });
+    }
+}

package/mcp-config-template.json

@@ -0,0 +1,18 @@
+{
+    "mcpServers": {
+        "vesper": {
+            "command": "npx",
+            "args": [
+                "-y",
+                "-p",
+                "@vespermcp/mcp-server@latest",
+                "vespermcp"
+            ],
+            "env": {
+                "KAGGLE_USERNAME": "your-kaggle-username",
+                "KAGGLE_KEY": "your-kaggle-api-key",
+                "HF_TOKEN": "your-huggingface-token"
+            }
+        }
+    }
+}

package/package.json

@@ -1,29 +1,101 @@
-{
-  "name": "vesper-wizard",
-  "version": "2.0.5",
-  "description": "Zero-friction setup wizard for Vesper — local MCP server, unified dataset API, and agent auto-config in 60 seconds",
-  "bin": {
-    "vesper-wizard": "wizard.js"
-  },
-  "keywords": [
-    "vesper",
-    "mcp",
-    "wizard",
-    "setup",
-    "datasets",
-    "machine-learning",
-    "huggingface",
-    "kaggle",
-    "openml"
-  ],
-  "author": "Vesper Team",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/vesper/mcp-server"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {}
-}
+{
+  "name": "vesper-wizard",
+  "version": "2.0.6",
+  "description": "AI-powered dataset discovery, quality analysis, and preparation MCP server with multimodal support (text, image, audio, video)",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "mcp-server": "./build/index.js",
+    "vespermcp": "./build/index.js",
+    "vesper-wizard": "scripts/wizard.js"
+  },
+  "files": [
+    "build/**/*",
+    "src/python/**/*",
+    "scripts/**/*",
+    "README.md",
+    "LICENSE",
+    "mcp-config-template.json"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"const fs=require('fs');const path=require('path');const src='src/python';const dest='build/python';const walk=(d)=>fs.readdirSync(d,{withFileTypes:true}).flatMap(e=>e.isDirectory()?walk(path.join(d,e.name)):[path.join(d,e.name)]);if(!fs.existsSync(dest))fs.mkdirSync(dest,{recursive:true});if(fs.existsSync(src)){for(const f of walk(src)){if(!f.endsWith('.py'))continue;const rel=path.relative(src,f);const out=path.join(dest,rel);fs.mkdirSync(path.dirname(out),{recursive:true});fs.copyFileSync(f,out);}}console.log('Copied Python scripts to build/python');\"",
+    "dev": "tsx watch src/index.ts",
+    "postinstall": "node scripts/postinstall.cjs",
+    "scrape": "tsx src/scripts/scrape-metadata.ts",
+    "massive-scrape": "tsx src/scripts/massive-scrape.ts",
+    "index": "tsx src/scripts/build-index.ts",
+    "search-cli": "tsx src/scripts/search-cli.ts",
+    "check-db": "tsx src/scripts/check-db.ts",
+    "test-jit": "tsx src/scripts/test-jit.ts",
+    "demo-ui": "tsx src/scripts/demo-ui.ts",
+    "fuse": "node build/index.js fuse",
+    "discover": "node build/index.js discover",
+    "download": "node build/index.js download",
+    "export": "node build/index.js export",
+    "config": "node build/index.js config",
+    "test-fusion-engine": "py src/python/test_fusion_engine.py",
+    "setup": "node build/index.js --setup",
+    "setup:silent": "node build/index.js --setup --silent",
+    "refresh-index": "node scripts/refresh-index.cjs",
+    "test": "vitest",
+    "start": "node build/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "dataset",
+    "machine-learning",
+    "data-quality",
+    "huggingface",
+    "kaggle",
+    "multimodal",
+    "image-analysis",
+    "audio-analysis",
+    "video-analysis",
+    "data-preparation",
+    "ai",
+    "ml"
+  ],
+  "author": "Vesper Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vesper/mcp-server"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "dependencies": {
+    "@huggingface/hub": "^2.7.1",
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "@polar-sh/nextjs": "^0.9.4",
+    "@supabase/supabase-js": "^2.98.0",
+    "@xenova/transformers": "^2.17.2",
+    "adm-zip": "^0.5.16",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "better-sqlite3": "^12.6.0",
+    "inquirer": "^13.3.0",
+    "lodash": "^4.17.21",
+    "uuid": "^13.0.0",
+    "zod": "^4.3.5",
+    "zod-to-json-schema": "^3.25.1"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/lodash": "^4.17.23",
+    "@types/node": "^25.0.9",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "packageManager": "pnpm@10.18.1+sha512.77a884a165cbba2d8d1c19e3b4880eee6d2fcabd0d879121e282196b80042351d5eb3ca0935fa599da1dc51265cc68816ad2bddd2a2de5ea9fdf92adbec7cd34"
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('\n🚀 Setting up Vesper MCP Server...\n');
+
+// 1. Check for Python
+try {
+    execSync('python --version', { stdio: 'pipe' });
+    console.log('✅ Python found');
+} catch (e) {
+    console.warn('⚠️  Python not found. Please install Python 3.8+ for full functionality.');
+    console.warn('   Image/audio/video analysis features will not work without Python.\n');
+    process.exit(0); // Don't fail installation
+}
+
+// 2. Install Python dependencies
+console.log('\n📦 Installing Python dependencies...');
+const pythonPackages = [
+    'opencv-python',
+    'pillow',
+    'numpy',
+    'librosa',
+    'soundfile',
+    'aiohttp',
+    'aiofiles',
+    'datasets',
+    'webdataset',
+    'kaggle'
+];
+
+try {
+    execSync(`python -m pip install ${pythonPackages.join(' ')}`, {
+        stdio: 'inherit',
+        timeout: 120000 // 2 minutes timeout
+    });
+    console.log('✅ Python dependencies installed');
+} catch (e) {
+    console.warn('⚠️  Failed to install some Python dependencies.');
+    console.warn('   You may need to install them manually:');
+    console.warn(`   pip install ${pythonPackages.join(' ')}\n`);
+}
+
+// 3. Create data directories
+const homeDir = process.env.HOME || process.env.USERPROFILE;
+const vesperDataDir = path.join(homeDir, '.vesper');
+const dirs = [
+    vesperDataDir,
+    path.join(vesperDataDir, 'data'),
+    path.join(vesperDataDir, 'data', 'raw'),
+    path.join(vesperDataDir, 'data', 'processed'),
+    path.join(vesperDataDir, 'datasets')
+];
+
+dirs.forEach(dir => {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+});
+
+console.log(`✅ Data directories created at ${vesperDataDir}`);
+
+// 4. Auto-configure Claude Desktop (Best Effort)
+console.log('\n⚙️  Attempting to auto-configure Claude Desktop...');
+
+function getClaudeConfigPath() {
+    const platform = process.platform;
+    const home = process.env.HOME || process.env.USERPROFILE;
+
+    if (platform === 'win32') {
+        return path.join(process.env.APPDATA, 'Claude', 'claude_desktop_config.json');
+    } else if (platform === 'darwin') {
+        return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    return null;
+}
+
+const configPath = getClaudeConfigPath();
+
+if (configPath && fs.existsSync(configPath)) {
+    try {
+        const configContent = fs.readFileSync(configPath, 'utf8');
+        let config = JSON.parse(configContent);
+
+        if (!config.mcpServers) config.mcpServers = {};
+
+        if (!config.mcpServers.vesper) {
+            config.mcpServers.vesper = {
+                command: "vesper",
+                args: [],
+                env: {
+                    "HF_TOKEN": ""
+                }
+            };
+
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            console.log(`✅ Automatically added 'vesper' to ${configPath}`);
+        } else {
+            console.log(`ℹ️  'vesper' is already configured in ${configPath}`);
+        }
+    } catch (e) {
+        console.warn(`⚠️  Could not auto-configure Claude Desktop: ${e.message}`);
+    }
+} else {
+    console.log('ℹ️  Claude Desktop config not found (skipping auto-config)');
+}
+
+console.log('\n✨ Vesper MCP Server installed successfully!\n');
+console.log('📖 Next steps:');
+console.log('   1. Restart your AI assistant (Cursor/Claude)');
+console.log('   2. Try: search_datasets(query="sentiment analysis")');
+console.log('\n💡 For full documentation, visit: https://github.com/vesper/mcp-server\n');