@vespermcp/mcp-server 1.2.10 → 1.2.12

package/build/cleaning/cleaner.js

@@ -63,7 +63,13 @@ export class DataCleaner {
                         reject(new Error(result.error));
                     }
                     else {
-                        resolve(result);
+                        resolve({
+                            success: true,
+                            rows_affected: Number(result.rows_affected ?? 0),
+                            columns_affected: Number(result.columns_affected ?? 0),
+                            output_path: result.output_path,
+                            logs: Array.isArray(result.logs) ? result.logs : [],
+                        });
                     }
                 }
                 catch (e) {

package/build/cleaning/executor.js

@@ -14,7 +14,7 @@ export class PipelineExecutor {
     /**
      * Run the full Auto-Cleaning Pipeline on a dataset file
      */
-    async runPipeline(datasetId, filePath, outputFormat = "csv", onProgress) {
+    async runPipeline(datasetId, filePath, outputFormat = "parquet", onProgress) {
         // ... (logging setup)
         const log = (m) => {
             console.error(`[Pipeline] ${m}`);
@@ -26,9 +26,10 @@ export class PipelineExecutor {
         // 2. Generate Plan
         log(`Generating cleaning plan...`);
         const plan = await this.planner.generatePlan(datasetId, qualityReport);
+        const rules = plan.operations;
         // If no cleaning needed, we still might need format conversion
         const needsConversion = !filePath.toLowerCase().endsWith(`.${outputFormat}`);
-        if (plan.operations.length === 0 && !needsConversion) {
+        if (rules.length === 0 && !needsConversion) {
             log(`No cleaning or conversion needed.`);
             return {
                 initial_quality: qualityReport,
@@ -42,9 +43,9 @@ export class PipelineExecutor {
             };
         }
         // 3. Execute Plan (includes conversion if requested)
-        log(`Executing ${plan.operations.length} operations (Format: ${outputFormat})...`);
-        plan.operations.forEach(op => console.error(`  - ${op.type}: ${op.reason}`));
-        const cleaningResult = await this.cleaner.clean(filePath, plan.operations, outputFormat);
+        log(`Executing ${rules.length} operations (Format: ${outputFormat})...`);
+        rules.forEach(op => console.error(`  - ${op.type}: ${op.reason}`));
+        const cleaningResult = await this.cleaner.clean(filePath, rules, outputFormat);
         if (cleaningResult.success) {
             log(`Cleaning complete. Output: ${cleaningResult.output_path}`);
         }

package/build/cleaning/planner.js

@@ -110,6 +110,10 @@ export class CleaningPlanner {
         }
         return plan;
     }
+    async generateRules(datasetId, report, ruleSet, targetInfo) {
+        const plan = await this.generatePlan(datasetId, report, ruleSet, targetInfo);
+        return plan.operations;
+    }
     shouldFixType(col) {
         if (col.inferred_type && col.inferred_type.includes("Numeric") && (col.type.includes("String") || col.type.includes("Utf8"))) {
             return true;

package/build/index.js

@@ -469,11 +469,20 @@ async function handlePrepareJob(jobId, query, requirements) {
  */
 async function handleCleanJob(jobId, datasetId, ops) {
     const update = (updates) => jobManager.updateJob(jobId, updates);
-    let filePath = path.join(dataRoot, "data", "raw", `${datasetId.replace(/\//g, "_")}.csv`);
+    const safeId = datasetId.replace(/\//g, "_");
+    const parquetPath = path.join(dataRoot, "data", "raw", `${safeId}.parquet`);
+    const csvPath = path.join(dataRoot, "data", "raw", `${safeId}.csv`);
+    let filePath = parquetPath;
+    if (!fs.existsSync(filePath)) {
+        filePath = csvPath;
+    }
     if (datasetId === "demo" || !fs.existsSync(filePath)) {
-        const demoPath = path.join(dataRoot, "e2e_demo_output", "raw_data.csv");
-        if (fs.existsSync(demoPath))
-            filePath = demoPath;
+        const demoParquetPath = path.join(dataRoot, "e2e_demo_output", "raw_data.parquet");
+        const demoCsvPath = path.join(dataRoot, "e2e_demo_output", "raw_data.csv");
+        if (fs.existsSync(demoParquetPath))
+            filePath = demoParquetPath;
+        else if (fs.existsSync(demoCsvPath))
+            filePath = demoCsvPath;
         else
             throw new Error(`Data file not found for ${datasetId}`);
     }
@@ -714,7 +723,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "export_dataset",
-                description: "Export a dataset to a local directory. Use format='feather' (default) for 5-10× faster writes than CSV. Add fast=true to skip quality/cleaning steps.",
+                description: "Export a dataset to a local directory. Use format='parquet' (default) for efficient analytics and broad interoperability. Add fast=true to skip quality/cleaning steps.",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -729,7 +738,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         format: {
                             type: "string",
                             enum: ["feather", "parquet", "csv", "jsonl", "arrow"],
-                            description: "Output format. feather (fastest), parquet (best compression), csv (human-readable). Default: feather.",
+                            description: "Output format. parquet (default, analytics-friendly), feather (fast local IO), csv (human-readable).",
                         },
                         compression: {
                             type: "string",
@@ -800,7 +809,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         output_format: {
                             type: "string",
                             enum: ["feather", "parquet", "csv", "jsonl", "arrow"],
-                            description: "Output format (default: feather).",
+                            description: "Output format (default: parquet).",
                         },
                         compression: {
                             type: "string",
@@ -1144,12 +1153,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         case "analyze_quality": {
             const datasetId = String(request.params.arguments?.dataset_id);
-            let filePath = path.join(dataRoot, "data", "raw", `${datasetId.replace(/\//g, "_")}.csv`);
+            const safeId = datasetId.replace(/\//g, "_");
+            const parquetPath = path.join(dataRoot, "data", "raw", `${safeId}.parquet`);
+            const csvPath = path.join(dataRoot, "data", "raw", `${safeId}.csv`);
+            let filePath = fs.existsSync(parquetPath) ? parquetPath : csvPath;
             // Demo Fallback for easy testing
             if (datasetId === "demo" || !fs.existsSync(filePath)) {
-                const demoPath = path.join(dataRoot, "e2e_demo_output", "raw_data.csv");
-                if (fs.existsSync(demoPath)) {
-                    filePath = demoPath;
+                const demoParquetPath = path.join(dataRoot, "e2e_demo_output", "raw_data.parquet");
+                const demoCsvPath = path.join(dataRoot, "e2e_demo_output", "raw_data.csv");
+                if (fs.existsSync(demoParquetPath)) {
+                    filePath = demoParquetPath;
+                }
+                else if (fs.existsSync(demoCsvPath)) {
+                    filePath = demoCsvPath;
                 }
                 else if (datasetId !== "demo") {
                     return {
@@ -1165,11 +1181,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         case "preview_cleaning": {
             const datasetId = String(request.params.arguments?.dataset_id);
-            let filePath = path.join(dataRoot, "data", "raw", `${datasetId.replace(/\//g, "_")}.csv`);
+            const safeId = datasetId.replace(/\//g, "_");
+            const parquetPath = path.join(dataRoot, "data", "raw", `${safeId}.parquet`);
+            const csvPath = path.join(dataRoot, "data", "raw", `${safeId}.csv`);
+            let filePath = fs.existsSync(parquetPath) ? parquetPath : csvPath;
             if (datasetId === "demo" || !fs.existsSync(filePath)) {
-                const demoPath = path.join(dataRoot, "e2e_demo_output", "raw_data.csv");
-                if (fs.existsSync(demoPath)) {
-                    filePath = demoPath;
+                const demoParquetPath = path.join(dataRoot, "e2e_demo_output", "raw_data.parquet");
+                const demoCsvPath = path.join(dataRoot, "e2e_demo_output", "raw_data.csv");
+                if (fs.existsSync(demoParquetPath)) {
+                    filePath = demoParquetPath;
+                }
+                else if (fs.existsSync(demoCsvPath)) {
+                    filePath = demoCsvPath;
                 }
                 else {
                     throw new McpError(ErrorCode.InvalidParams, `Local data file not found for ${datasetId}. Please run prepare_dataset first.`);
@@ -1291,7 +1314,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // If NOT fast mode, run quality/cleaning pipeline first (only for csv/parquet compat)
             if (!fastMode) {
                 const currentExt = path.extname(sourcePath).substring(1).toLowerCase();
-                const pipelineFmt = (requestedFormat === "csv" || requestedFormat === "parquet") ? requestedFormat : "csv";
+                const pipelineFmt = (requestedFormat === "csv" || requestedFormat === "parquet") ? requestedFormat : "parquet";
                 if (currentExt !== pipelineFmt) {
                     console.error(`[Export] Running quality/cleaning pipeline (use fast=true to skip)...`);
                     try {

package/build/ingestion/ingestor.js

@@ -152,7 +152,7 @@ export class DataIngestor {
     /**
      * Generates a safe local filename for a dataset ID
      */
-    getTargetPath(datasetId, extension = "csv") {
+    getTargetPath(datasetId, extension = "parquet") {
         const safeId = datasetId.replace(/\//g, "_").replace(/:/g, "_");
         return path.join(this.rawDataDir, `${safeId}.${extension}`);
     }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@vespermcp/mcp-server",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "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": {
     "vespermcp": "./build/index.js",
-    "@vespermcp/mcp-server": "./build/index.js"
+    "@vespermcp/mcp-server": "./build/index.js",
+    "vesper-wizard": "src/scripts/wizard.js"
   },
   "files": [
     "build/**/*",
@@ -72,6 +73,7 @@
     "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",
@@ -91,5 +93,6 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.17"
-  }
+  },
+  "packageManager": "pnpm@10.18.1+sha512.77a884a165cbba2d8d1c19e3b4880eee6d2fcabd0d879121e282196b80042351d5eb3ca0935fa599da1dc51265cc68816ad2bddd2a2de5ea9fdf92adbec7cd34"
 }

package/src/scripts/wizard.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+// Vesper Wizard CLI: Interactive setup for fast configuration
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+
+async function main() {
+  console.log('\n🧙 Welcome to the Vesper Wizard!\n');
+
+  // Step 1: Project basics
+  const { projectName } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: path.basename(process.cwd()),
+    },
+  ]);
+
+  // Step 2: Data directory
+  const { dataDir } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'dataDir',
+      message: 'Path to your data directory:',
+      default: './datasets',
+    },
+  ]);
+
+  // Step 3: Default export format
+  const { exportFormat } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'exportFormat',
+      message: 'Default export format:',
+      choices: ['parquet', 'csv', 'feather'],
+      default: 'parquet',
+    },
+  ]);
+
+  // Step 4: Add tokens/credentials
+  const { addTokens } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'addTokens',
+      message: 'Would you like to add API tokens or credentials now?',
+      default: true,
+    },
+  ]);
+  let tokens = {};
+  if (addTokens) {
+    const { kaggleToken } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'kaggleToken',
+        message: 'Kaggle API token (leave blank to skip):',
+      },
+    ]);
+    if (kaggleToken) tokens.kaggle = kaggleToken;
+    // Add more tokens as needed
+  }
+
+  // Step 5: Write config file
+  const config = {
+    project: projectName,
+    dataDir,
+    exportFormat,
+    tokens,
+  };
+  const configPath = path.join(process.cwd(), 'vesper-mcp-config.json');
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(`\n✅ Configuration saved to ${configPath}`);
+  console.log('\n🎉 Vesper is ready to use!\n');
+}
+
+main();