@vespermcp/mcp-server 1.1.3 → 1.2.0

package/README.md

@@ -89,6 +89,40 @@ Vesper attempts to auto-configure itself! Restart Claude and check. If not:
 - `KAGGLE_USERNAME` & `KAGGLE_KEY`: For Kaggle dataset access
 - `HF_TOKEN`: For private HuggingFace datasets
 
+### Optional Kaggle Setup (Not Required)
+
+Core Vesper works without any API keys. Keys are only needed when you explicitly use Kaggle or gated Hugging Face.
+
+Install optional Kaggle client only if you need Kaggle source access:
+
+```bash
+pip install kaggle
+```
+
+```bash
+vespermcp config keys
+```
+
+The setup wizard supports skip and stores keys securely via OS keyring when available,
+with fallback to `~/.vesper/config.toml`.
+
+or use Kaggle's native file:
+
+- `~/.kaggle/kaggle.json`
+
+If credentials are missing and you run Kaggle commands, Vesper shows:
+
+`Kaggle support requires API key. Run 'vespermcp config keys' (30 seconds).`
+
+### CLI Examples
+
+```bash
+vespermcp discover --source kaggle "credit risk" --limit 10
+vespermcp discover --source huggingface "credit risk" --limit 10
+vespermcp download kaggle username/dataset-name
+vespermcp download kaggle https://www.kaggle.com/datasets/username/dataset-name --target-dir ./data
+```
+
 ## 🚀 Quick Start
 
 After installation and configuration, restart your AI assistant and try:

package/build/config/secure-keys.js

@@ -0,0 +1,51 @@
+import { spawnSync } from "child_process";
+import path from "path";
+import fs from "fs";
+export class SecureKeysManager {
+    pythonPath = "python";
+    scriptPath;
+    constructor(buildDir = process.cwd()) {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || buildDir;
+        const dataRoot = path.join(homeDir, ".vesper");
+        const scriptPath0 = path.resolve(dataRoot, "python", "config.py");
+        const scriptPath1 = path.resolve(buildDir, "python", "config.py");
+        const scriptPath2 = path.resolve(buildDir, "..", "src", "python", "config.py");
+        if (fs.existsSync(scriptPath0))
+            this.scriptPath = scriptPath0;
+        else if (fs.existsSync(scriptPath1))
+            this.scriptPath = scriptPath1;
+        else if (fs.existsSync(scriptPath2))
+            this.scriptPath = scriptPath2;
+        else
+            this.scriptPath = scriptPath0;
+        if (process.platform === "win32")
+            this.pythonPath = "py";
+    }
+    getAll() {
+        const result = spawnSync(this.pythonPath, [this.scriptPath, "all"], { encoding: "utf-8" });
+        if (result.status !== 0)
+            return {};
+        try {
+            const parsed = JSON.parse(result.stdout || "{}");
+            if (!parsed.ok)
+                return {};
+            return (parsed.data || {});
+        }
+        catch {
+            return {};
+        }
+    }
+    set(name, value) {
+        const result = spawnSync(this.pythonPath, [this.scriptPath, "set", name, value], { encoding: "utf-8" });
+        if (result.status !== 0) {
+            return { ok: false, error: result.stderr || "Failed to store key" };
+        }
+        try {
+            const parsed = JSON.parse(result.stdout || "{}");
+            return { ok: !!parsed.ok, method: parsed.method, error: parsed.error };
+        }
+        catch {
+            return { ok: false, error: "Invalid response from config helper" };
+        }
+    }
+}

package/build/config/user-config.js

@@ -0,0 +1,48 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+export class UserConfigStore {
+    configPath;
+    constructor(dataRoot) {
+        const homeDir = os.homedir() || process.env.HOME || process.env.USERPROFILE || process.cwd();
+        const root = dataRoot || path.join(homeDir, ".vesper");
+        if (!fs.existsSync(root)) {
+            fs.mkdirSync(root, { recursive: true });
+        }
+        this.configPath = path.join(root, "config.json");
+    }
+    getPath() {
+        return this.configPath;
+    }
+    load() {
+        if (!fs.existsSync(this.configPath))
+            return {};
+        try {
+            const raw = fs.readFileSync(this.configPath, "utf8");
+            const parsed = JSON.parse(raw);
+            return parsed || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    save(config) {
+        const parent = path.dirname(this.configPath);
+        if (!fs.existsSync(parent))
+            fs.mkdirSync(parent, { recursive: true });
+        fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf8");
+    }
+    setKaggleCredentials(username, key) {
+        const cfg = this.load();
+        cfg.kaggle = { username, key };
+        this.save(cfg);
+    }
+    getKaggleCredentials() {
+        const cfg = this.load();
+        return cfg.kaggle || {};
+    }
+    hasKaggleCredentials() {
+        const creds = this.getKaggleCredentials();
+        return !!(creds.username && creds.key);
+    }
+}

package/build/fusion/engine.js

@@ -0,0 +1,69 @@
+import { spawn } from "child_process";
+import path from "path";
+import fs from "fs";
+export class DataFusionEngine {
+    pythonPath = "python";
+    scriptPath;
+    constructor(buildDir = process.cwd()) {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || buildDir;
+        const dataRoot = path.join(homeDir, ".vesper");
+        const scriptPath0 = path.resolve(dataRoot, "python", "fusion_engine.py");
+        const scriptPath1 = path.resolve(buildDir, "python", "fusion_engine.py");
+        const scriptPath2 = path.resolve(buildDir, "..", "src", "python", "fusion_engine.py");
+        const scriptPath3 = path.resolve(buildDir, "..", "python", "fusion_engine.py");
+        if (fs.existsSync(scriptPath0)) {
+            this.scriptPath = scriptPath0;
+        }
+        else if (fs.existsSync(scriptPath1)) {
+            this.scriptPath = scriptPath1;
+        }
+        else if (fs.existsSync(scriptPath2)) {
+            this.scriptPath = scriptPath2;
+        }
+        else if (fs.existsSync(scriptPath3)) {
+            this.scriptPath = scriptPath3;
+        }
+        else {
+            this.scriptPath = scriptPath0;
+        }
+        if (process.platform === "win32") {
+            this.pythonPath = "py";
+        }
+    }
+    async fuse(sourcePaths, outputPath, options = {}) {
+        return new Promise((resolve, reject) => {
+            if (!Array.isArray(sourcePaths) || sourcePaths.length < 2) {
+                reject(new Error("At least 2 source paths are required for fusion"));
+                return;
+            }
+            const args = [
+                this.scriptPath,
+                JSON.stringify(sourcePaths),
+                outputPath,
+                JSON.stringify(options),
+            ];
+            const processRef = spawn(this.pythonPath, args);
+            let stdout = "";
+            let stderr = "";
+            processRef.stdout.on("data", (data) => (stdout += data.toString()));
+            processRef.stderr.on("data", (data) => (stderr += data.toString()));
+            processRef.on("close", (code) => {
+                if (code !== 0) {
+                    reject(new Error(`Fusion failed: ${stderr || stdout}`));
+                    return;
+                }
+                try {
+                    const result = JSON.parse(stdout);
+                    if (result.error) {
+                        reject(new Error(result.error));
+                        return;
+                    }
+                    resolve(result);
+                }
+                catch (e) {
+                    reject(new Error(`Failed to parse fusion output: ${stdout}`));
+                }
+            });
+        });
+    }
+}