@vespermcp/mcp-server 1.0.4 → 1.0.6

package/README.md

@@ -31,15 +31,17 @@ Vesper is a Model Context Protocol (MCP) server that helps you find, analyze, an
 
 ## 📦 Installation
 
-### Install Globally (Recommended)
+### Option A: Install via NPX (Easiest)
+Run the setup wizard to automatically configure Vesper for Cursor, Claude Desktop, and VS Code:
 
 ```bash
-npm install -g @vespermcp/mcp-server
+npx @vespermcp/mcp-server@latest --setup
 ```
 
-### Option B: Install via Git
+### Option B: Install Globally
 ```bash
-npm install -g git+https://github.com/vespermcp/mcp-server.git
+npm install -g @vespermcp/mcp-server
+vesper --setup
 ```
 
 The postinstall script will automatically:

package/build/cleaning/cleaner.js

@@ -1,10 +1,35 @@
 import { spawn } from "child_process";
 import path from "path";
+import fs from "fs";
 export class DataCleaner {
     pythonPath = "python";
     scriptPath;
-    constructor(projectRoot = process.cwd()) {
-        this.scriptPath = path.join(projectRoot, "src", "python", "cleaner.py");
+    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", "cleaner.py");
+        const scriptPath1 = path.resolve(buildDir, "python", "cleaner.py");
+        const scriptPath2 = path.resolve(buildDir, "..", "src", "python", "cleaner.py");
+        const scriptPath3 = path.resolve(buildDir, "..", "python", "cleaner.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; // Final fallback
+        }
+        // Detect Python command (Windows may use 'py' instead of 'python')
+        if (process.platform === "win32") {
+            this.pythonPath = "py";
+        }
     }
     /**
      * Execute a list of cleaning operations on a file

package/build/cleaning/executor.js

@@ -5,10 +5,11 @@ export class PipelineExecutor {
     analyzer;
     planner;
     cleaner;
-    constructor(projectRoot = process.cwd()) {
-        this.analyzer = new QualityAnalyzer(undefined, projectRoot);
-        this.planner = new CleaningPlanner();
-        this.cleaner = new DataCleaner(projectRoot);
+    constructor(dataRoot = process.cwd(), buildDir) {
+        // Use buildDir for analyzer and cleaner (where Python scripts are), dataRoot for data operations
+        this.analyzer = new QualityAnalyzer(undefined, buildDir || dataRoot);
+        this.planner = new CleaningPlanner(undefined, buildDir || dataRoot);
+        this.cleaner = new DataCleaner(buildDir || dataRoot);
     }
     /**
      * Run the full Auto-Cleaning Pipeline on a dataset file
@@ -16,7 +17,7 @@ export class PipelineExecutor {
     async runPipeline(datasetId, filePath, outputFormat = "csv", onProgress) {
         // ... (logging setup)
         const log = (m) => {
-            console.log(`[Pipeline] ${m}`);
+            console.error(`[Pipeline] ${m}`);
             if (onProgress)
                 onProgress(m);
         };
@@ -42,7 +43,7 @@ export class PipelineExecutor {
         }
         // 3. Execute Plan (includes conversion if requested)
         log(`Executing ${plan.operations.length} operations (Format: ${outputFormat})...`);
-        plan.operations.forEach(op => console.log(`  - ${op.type}: ${op.reason}`));
+        plan.operations.forEach(op => console.error(`  - ${op.type}: ${op.reason}`));
         const cleaningResult = await this.cleaner.clean(filePath, plan.operations, outputFormat);
         if (cleaningResult.success) {
             log(`Cleaning complete. Output: ${cleaningResult.output_path}`);

package/build/cleaning/planner.js

@@ -1,16 +1,19 @@
+import { TargetDetector } from "../preparation/target-detector.js";
 export class CleaningPlanner {
     cache;
-    constructor(cache) {
+    targetDetector;
+    constructor(cache, buildDir = process.cwd()) {
         this.cache = cache;
+        this.targetDetector = new TargetDetector(buildDir);
     }
     /**
      * Generate a cleaning plan based on the quality report and optional custom rules
      */
-    async generatePlan(datasetId, report, ruleSet) {
+    async generatePlan(datasetId, report, ruleSet, targetInfo) {
         if (this.cache) {
             const cached = await this.cache.getPlan(datasetId, { report, ruleSet });
             if (cached) {
-                console.log(`[CleaningPlanner] Cache hit for ${datasetId}`);
+                console.error(`[CleaningPlanner] Cache hit for ${datasetId}`);
                 return cached;
             }
         }
@@ -66,7 +69,16 @@ export class CleaningPlanner {
                 });
             }
         }
-        // 3. Apply Custom Rules
+        // 3. Target Unification
+        if (targetInfo && targetInfo.target !== "target" && targetInfo.confidence > 0.7) {
+            ops.push({
+                type: "RenameTarget",
+                params: { old_name: targetInfo.target, new_name: "target" },
+                reason: `Detected target '${targetInfo.target}' with high confidence (${targetInfo.confidence.toFixed(2)})`
+            });
+            estimatedColsSaved++; // Logic fix: effectively "saving" a column by standardizing it
+        }
+        // 4. Apply Custom Rules
         if (ruleSet) {
             for (const rule of ruleSet.rules) {
                 const targets = rule.condition.column === "*"

package/build/config/config-manager.js

@@ -0,0 +1,199 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+export class ConfigManager {
+    getHomeDir() {
+        return os.homedir();
+    }
+    getConfigPaths() {
+        const home = this.getHomeDir();
+        const isWin = process.platform === "win32";
+        const appData = process.env.APPDATA || "";
+        return {
+            "claude-desktop": {
+                name: "Claude Desktop",
+                path: isWin
+                    ? path.join(appData, "Claude", "claude_desktop_config.json")
+                    : path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+                key: "mcpServers"
+            },
+            "cursor": {
+                name: "Cursor",
+                path: isWin
+                    ? path.join(appData, "Cursor", "User", "globalStorage", "rohit-gohri.cursor-mcp", "mcp.json")
+                    : path.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "rohit-gohri.cursor-mcp", "mcp.json"),
+                key: "mcpServers"
+            },
+            "vscode-cline": {
+                name: "VS Code (Cline)",
+                path: isWin
+                    ? path.join(appData, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+                    : path.join(home, "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+                key: "mcpServers"
+            },
+            "vscode-roo-code": {
+                name: "VS Code (Roo Code)",
+                path: isWin
+                    ? path.join(appData, "Code", "User", "globalStorage", "RooVeterans.roo-cline", "settings", "cline_mcp_settings.json")
+                    : path.join(home, "Library", "Application Support", "Code", "User", "globalStorage", "RooVeterans.roo-cline", "settings", "cline_mcp_settings.json"),
+                key: "mcpServers"
+            },
+            "cursor-project": {
+                name: "Cursor (Project-specific)",
+                path: path.join(process.cwd(), ".cursor", "mcp.json"),
+                key: "mcpServers"
+            },
+            "vscode-copilot": {
+                name: "VS Code (Copilot)",
+                path: path.join(home, ".copilot", "mcp-config.json"),
+                key: "mcpServers"
+            },
+            "vscode-global": {
+                name: "VS Code (Standard MCP)",
+                path: isWin
+                    ? path.join(appData, "Code", "User", "mcp.json")
+                    : path.join(home, "Library", "Application Support", "Code", "User", "mcp.json"),
+                key: "mcpServers"
+            },
+            "vscode-project": {
+                name: "VS Code (Project-specific)",
+                path: path.join(process.cwd(), ".vscode", "mcp.json"),
+                key: "mcpServers"
+            },
+            "vscode-insiders": {
+                name: "VS Code Insiders",
+                path: isWin
+                    ? path.join(appData, "Code - Insiders", "User", "mcp.json")
+                    : path.join(home, "Library", "Application Support", "Code - Insiders", "User", "mcp.json"),
+                key: "mcpServers"
+            },
+            "vscode-settings": {
+                name: "VS Code (Settings.json)",
+                path: isWin
+                    ? path.join(appData, "Code", "User", "settings.json")
+                    : path.join(home, "Library", "Application Support", "Code", "User", "settings.json"),
+                key: "github.copilot.chat.mcp.servers"
+            },
+            "vscode-root": {
+                name: "VS Code (Workspace Root)",
+                path: path.join(process.cwd(), "mcp.json"),
+                key: "mcpServers"
+            }
+        };
+    }
+    detectIDEs() {
+        const paths = this.getConfigPaths();
+        const detected = [];
+        const termProgram = (process.env.TERM_PROGRAM || "").toLowerCase();
+        const appData = process.env.APPDATA || "";
+        const home = this.getHomeDir();
+        for (const [key, cp] of Object.entries(paths)) {
+            const isClaude = key === "claude-desktop";
+            const isCursor = key === "cursor";
+            const isVSCode = key.startsWith("vscode");
+            const isCopilot = key === "vscode-copilot";
+            const isStandard = key === "vscode-global";
+            const isSettings = key === "vscode-settings";
+            const isRoot = key === "vscode-root";
+            const hasClaudeFolder = fs.existsSync(path.join(appData, "Claude"));
+            const hasCursorFolder = fs.existsSync(path.join(appData, "Cursor")) || fs.existsSync(path.join(home, ".cursor"));
+            const hasCodeFolder = fs.existsSync(path.join(appData, "Code")) || fs.existsSync(path.join(home, ".vscode"));
+            const hasInsidersFolder = fs.existsSync(path.join(appData, "Code - Insiders"));
+            const hasCopilotFolder = fs.existsSync(path.join(home, ".copilot"));
+            if (process.env.VESPER_DEBUG) {
+                console.log(`[Debug] Checking ${key}:`);
+                console.log(`  - Config Path: ${cp.path} (${fs.existsSync(cp.path) ? "EXISTS" : "MISSING"})`);
+                if (isClaude)
+                    console.log(`  - Claude Folder: ${path.join(appData, "Claude")} (${hasClaudeFolder ? "EXISTS" : "MISSING"})`);
+                if (isCursor)
+                    console.log(`  - Cursor Folder: ${path.join(appData, "Cursor")} (${hasCursorFolder ? "EXISTS" : "MISSING"})`);
+                if (isVSCode)
+                    console.log(`  - Code Folder: ${path.join(appData, "Code")} (${hasCodeFolder ? "EXISTS" : "MISSING"})`);
+                if (isCopilot)
+                    console.log(`  - Copilot Folder: ${path.join(this.getHomeDir(), ".copilot")} (${hasCopilotFolder ? "EXISTS" : "MISSING"})`);
+            }
+            const isCurrentIDE = (isCursor && (termProgram.includes("cursor") || (termProgram === "vscode" && hasCursorFolder))) ||
+                (isClaude && termProgram.includes("claude")) ||
+                (isVSCode && termProgram === "vscode" && (hasCodeFolder || hasInsidersFolder)) ||
+                (isCopilot && hasCopilotFolder) ||
+                (isStandard && termProgram === "vscode") ||
+                (isSettings && termProgram === "vscode");
+            // Also check if the config file actually exists OR the root folder exists
+            const shouldDetectByFolder = (isClaude && hasClaudeFolder) ||
+                (isCursor && hasCursorFolder) ||
+                (isVSCode && hasCodeFolder) ||
+                (key === "vscode-insiders" && hasInsidersFolder) ||
+                (isCopilot && hasCopilotFolder) ||
+                (isStandard && hasCodeFolder) ||
+                (isSettings && hasCodeFolder) ||
+                (isRoot && fs.existsSync(process.cwd()));
+            if (shouldDetectByFolder || fs.existsSync(cp.path) || isCurrentIDE || key === "cursor-project" || key === "vscode-project" || key === "vscode-root") {
+                let displayName = cp.name;
+                if (isCurrentIDE) {
+                    displayName += " (Current Terminal)";
+                }
+                detected.push({ ...cp, name: displayName });
+            }
+        }
+        return detected.filter((v, i, a) => a.findIndex(t => t.path === v.path) === i);
+    }
+    async installTo(configPath) {
+        try {
+            console.log(`[Vesper Setup] Installing to ${configPath.name} at ${configPath.path}...`);
+            let config = {};
+            if (fs.existsSync(configPath.path)) {
+                try {
+                    const content = fs.readFileSync(configPath.path, "utf-8").trim();
+                    config = content ? JSON.parse(content) : {};
+                }
+                catch (e) {
+                    console.warn(`[Vesper Setup] Could not parse ${configPath.path}, starting fresh`);
+                    config = {};
+                }
+            }
+            else {
+                console.log(`[Vesper Setup] Creating directory: ${path.dirname(configPath.path)}`);
+                fs.mkdirSync(path.dirname(configPath.path), { recursive: true });
+            }
+            // Handle nested keys (e.g., "github.copilot.chat.mcp.servers")
+            const keys = configPath.key.split('.');
+            let current = config;
+            for (let i = 0; i < keys.length - 1; i++) {
+                if (!current[keys[i]])
+                    current[keys[i]] = {};
+                current = current[keys[i]];
+            }
+            const lastKey = keys[keys.length - 1];
+            const mcpServers = current[lastKey] || {};
+            // Use the portable npx command as requested
+            // We use both 'vesper' (clean) and 'vespermcp' (legacy/alias) for compatibility
+            const isWin = process.platform === "win32";
+            const serverConfig = {
+                command: isWin ? "npx.cmd" : "npx",
+                args: ["-y", "@vespermcp/mcp-server@latest"],
+                env: {
+                    "HF_TOKEN": "YOUR_HUGGINGFACE_TOKEN_HERE",
+                    // Empty by default to avoid clutter, user can add if needed
+                }
+            };
+            mcpServers["vesper"] = serverConfig;
+            // Also add alias for easy upgrading
+            mcpServers["@vespermcp/mcp-server"] = serverConfig;
+            current[lastKey] = mcpServers;
+            const content = JSON.stringify(config, null, 2);
+            if (process.env.VESPER_DEBUG) {
+                console.log(`[Vesper Setup] Writing to ${configPath.path}:`);
+                console.log(content);
+            }
+            fs.writeFileSync(configPath.path, content, "utf8");
+            // Verify write
+            const finalSize = fs.statSync(configPath.path).size;
+            console.log(`[Vesper Setup] Successfully wrote ${finalSize} bytes to ${configPath.name}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to install to ${configPath.name}:`, error);
+            return false;
+        }
+    }
+}

package/build/export/exporter.js

@@ -4,8 +4,32 @@ import fs from "fs";
 export class DataExporter {
     pythonPath = "python";
     scriptPath;
-    constructor(projectRoot = process.cwd()) {
-        this.scriptPath = path.join(projectRoot, "src", "python", "export_engine.py");
+    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", "export_engine.py");
+        const scriptPath1 = path.resolve(buildDir, "python", "export_engine.py");
+        const scriptPath2 = path.resolve(buildDir, "..", "src", "python", "export_engine.py");
+        const scriptPath3 = path.resolve(buildDir, "..", "python", "export_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;
+        }
+        // Detect Python command
+        if (process.platform === "win32") {
+            this.pythonPath = "py";
+        }
     }
     /**
      * Exports a dataset file to a specified format