vesper-wizard 2.0.5 → 2.0.6

package/build/config/config-manager.js

@@ -0,0 +1,221 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+export class ConfigManager {
+    getHomeDir() {
+        return os.homedir();
+    }
+    /**
+     * All known coding agent configuration paths.
+     * Based on the `add-mcp` standard used by the MCP ecosystem.
+     */
+    getAllAgents() {
+        const home = this.getHomeDir();
+        const isWin = process.platform === "win32";
+        const isMac = process.platform === "darwin";
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        const agents = [
+            // Claude Code: ~/.claude.json
+            {
+                name: "Claude Code",
+                path: path.join(home, ".claude.json"),
+                format: "json-mcpServers",
+                serverType: "stdio",
+            },
+            // Claude Desktop: %APPDATA%/Claude/claude_desktop_config.json
+            {
+                name: "Claude Desktop",
+                path: isWin
+                    ? path.join(appData, "Claude", "claude_desktop_config.json")
+                    : isMac
+                        ? path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+                        : path.join(home, ".config", "claude", "claude_desktop_config.json"),
+                format: "json-mcpServers",
+                serverType: "stdio",
+            },
+            // Cursor: ~/.cursor/mcp.json
+            {
+                name: "Cursor",
+                path: path.join(home, ".cursor", "mcp.json"),
+                format: "json-mcpServers",
+                serverType: "stdio",
+            },
+            // VS Code: %APPDATA%/Code/User/mcp.json (uses "servers" key, NOT "mcpServers")
+            {
+                name: "VS Code",
+                path: isWin
+                    ? path.join(appData, "Code", "User", "mcp.json")
+                    : isMac
+                        ? path.join(home, "Library", "Application Support", "Code", "User", "mcp.json")
+                        : path.join(home, ".config", "Code", "User", "mcp.json"),
+                format: "json-servers",
+                serverType: "stdio",
+            },
+            // Codex: ~/.codex/config.toml
+            {
+                name: "Codex",
+                path: path.join(home, ".codex", "config.toml"),
+                format: "toml",
+                serverType: "stdio",
+            },
+            // Antigravity / Gemini CLI: ~/.gemini/settings.json
+            {
+                name: "Antigravity",
+                path: path.join(home, ".gemini", "settings.json"),
+                format: "json-mcpServers",
+                serverType: "stdio",
+            },
+        ];
+        return agents;
+    }
+    /**
+     * Detect which agents are installed on this machine.
+     */
+    detectIDEs() {
+        const agents = this.getAllAgents();
+        const detected = [];
+        for (const agent of agents) {
+            const configDir = path.dirname(agent.path);
+            const configExists = fs.existsSync(agent.path);
+            const dirExists = fs.existsSync(configDir);
+            if (configExists || dirExists) {
+                detected.push(agent);
+            }
+        }
+        return detected;
+    }
+    /**
+     * Build the server config object for Vesper.
+     */
+    getServerConfig() {
+        const isWin = process.platform === "win32";
+        return {
+            command: isWin ? "npx.cmd" : "npx",
+            args: ["-y", "-p", "@vespermcp/mcp-server@latest", "vespermcp"],
+        };
+    }
+    /**
+     * Install Vesper to a single agent configuration.
+     */
+    async installTo(agent) {
+        try {
+            console.log(`[Vesper Setup] Installing to ${agent.name}...`);
+            if (agent.format === "toml") {
+                return this.installToToml(agent);
+            }
+            // JSON-based agents
+            let config = {};
+            if (fs.existsSync(agent.path)) {
+                try {
+                    const content = fs.readFileSync(agent.path, "utf-8").trim();
+                    config = content ? JSON.parse(content) : {};
+                }
+                catch (e) {
+                    console.warn(`[Vesper Setup] Could not parse ${agent.path}, starting fresh`);
+                    config = {};
+                }
+            }
+            else {
+                fs.mkdirSync(path.dirname(agent.path), { recursive: true });
+            }
+            const vesperConfig = this.getServerConfig();
+            const serverEntry = {
+                command: vesperConfig.command,
+                args: vesperConfig.args,
+            };
+            // Determine the correct key based on agent format
+            if (agent.format === "json-servers") {
+                // VS Code native MCP format: { "servers": { "vesper": { "type": "stdio", "command": ..., "args": ... } } }
+                if (!config.servers)
+                    config.servers = {};
+                config.servers["vesper"] = {
+                    type: "stdio",
+                    ...serverEntry,
+                };
+                console.log(`  ✓ Added to "servers" key (VS Code native format)`);
+            }
+            else {
+                // Standard mcpServers format: { "mcpServers": { "vesper": { "command": ..., "args": ... } } }
+                if (!config.mcpServers)
+                    config.mcpServers = {};
+                config.mcpServers["vesper"] = serverEntry;
+                console.log(`  ✓ Added to "mcpServers" key`);
+            }
+            fs.writeFileSync(agent.path, JSON.stringify(config, null, 2), "utf8");
+            const size = fs.statSync(agent.path).size;
+            console.log(`  ✓ ${agent.name}: ${agent.path} (${size} bytes)`);
+            return true;
+        }
+        catch (error) {
+            console.error(`  ✗ Failed to install to ${agent.name}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Install to TOML-based agents (Codex).
+     */
+    installToToml(agent) {
+        try {
+            let content = "";
+            if (fs.existsSync(agent.path)) {
+                content = fs.readFileSync(agent.path, "utf-8");
+            }
+            else {
+                fs.mkdirSync(path.dirname(agent.path), { recursive: true });
+            }
+            // Check if vesper is already configured
+            if (content.includes("[mcp_servers.vesper]")) {
+                console.log(`  ✓ ${agent.name}: Already configured`);
+                return true;
+            }
+            const vesperConfig = this.getServerConfig();
+            const isWin = process.platform === "win32";
+            const tomlEntry = `
+[mcp_servers.vesper]
+command = "${vesperConfig.command}"
+args = [${vesperConfig.args.map(a => `"${a}"`).join(", ")}]
+`;
+            content += tomlEntry;
+            fs.writeFileSync(agent.path, content, "utf8");
+            console.log(`  ✓ ${agent.name}: ${agent.path}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`  ✗ Failed to install to ${agent.name}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Install Vesper to ALL detected agents automatically.
+     */
+    async installToAll() {
+        const agents = this.detectIDEs();
+        const success = [];
+        const failed = [];
+        console.log(`\n📦 Installing Vesper to ${agents.length} detected agents...\n`);
+        for (const agent of agents) {
+            const result = await this.installTo(agent);
+            if (result) {
+                success.push(agent.name);
+            }
+            else {
+                failed.push(agent.name);
+            }
+        }
+        console.log(`\n┌─────────────────────────────────────────────┐`);
+        console.log(`│  Installation Summary                       │`);
+        console.log(`├─────────────────────────────────────────────┤`);
+        if (success.length > 0) {
+            for (const name of success) {
+                console.log(`│  ✓ ${name.padEnd(40)}│`);
+            }
+        }
+        if (failed.length > 0) {
+            for (const name of failed) {
+                console.log(`│  ✗ ${name.padEnd(40)}│`);
+            }
+        }
+        console.log(`└─────────────────────────────────────────────┘\n`);
+        return { success, failed };
+    }
+}

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/data/processing-worker.js

@@ -0,0 +1,23 @@
+import { parentPort } from "worker_threads";
+if (parentPort) {
+    parentPort.on("message", (data) => {
+        const { records, task, params } = data;
+        let results = [];
+        switch (task) {
+            case "transform":
+                results = records.map(r => {
+                    // Simulated transformation (e.g. alignment/harmonization logic)
+                    const updated = { ...r, processed_at: new Date().toISOString() };
+                    // Complex CPU bound work simulation
+                    let sum = 0;
+                    for (let i = 0; i < 1000; i++)
+                        sum += i;
+                    return updated;
+                });
+                break;
+            default:
+                results = records;
+        }
+        parentPort?.postMessage(results);
+    });
+}

package/build/data/streaming.js

@@ -0,0 +1,38 @@
+export class StreamProcessor {
+    /**
+     * Processes a readable stream in chunks.
+     */
+    static async processInChunks(stream, options, processor) {
+        let chunk = [];
+        const results = [];
+        let totalProcessed = 0;
+        for await (const record of stream) {
+            // Sampling logic
+            if (options.samplePercentage !== undefined) {
+                if (Math.random() * 100 > options.samplePercentage) {
+                    continue;
+                }
+            }
+            chunk.push(record);
+            if (chunk.length >= options.chunkSize) {
+                const processedChunk = await processor(chunk);
+                results.push(...processedChunk);
+                totalProcessed += chunk.length;
+                chunk = [];
+            }
+        }
+        // Process remaining
+        if (chunk.length > 0) {
+            const processedChunk = await processor(chunk);
+            results.push(...processedChunk);
+            totalProcessed += chunk.length;
+        }
+        return results;
+    }
+    /**
+     * Creates a sampler stream that only emits a percentage of records.
+     */
+    static createSampler(percentage) {
+        return () => Math.random() * 100 <= percentage;
+    }
+}

package/build/data/worker-pool.js

@@ -0,0 +1,39 @@
+import { Worker } from "worker_threads";
+import path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export class WorkerPool {
+    poolSize;
+    workers = [];
+    queue = [];
+    activeWorkers = 0;
+    constructor(poolSize = 4) {
+        this.poolSize = poolSize;
+        const workerPath = path.resolve(__dirname, "processing-worker.js");
+        // Note: In development with tsx, we might need to handle .ts vs .js
+    }
+    async process(records, task = "transform") {
+        return new Promise((resolve, reject) => {
+            const worker = new Worker(new URL("./processing-worker.ts", import.meta.url), {
+                execArgv: ["--import", "tsx"]
+            });
+            worker.postMessage({ records, task });
+            worker.on("message", (results) => {
+                worker.terminate();
+                resolve(results);
+            });
+            worker.on("error", reject);
+        });
+    }
+    /**
+     * Splits records into chunks and processes them in parallel across workers.
+     */
+    async processParallel(records, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < records.length; i += chunkSize) {
+            chunks.push(records.slice(i, i + chunkSize));
+        }
+        const results = await Promise.all(chunks.map(chunk => this.process(chunk)));
+        return results.flat();
+    }
+}

package/build/export/exporter.js

@@ -0,0 +1,69 @@
+import { spawn } from "child_process";
+import path from "path";
+import fs from "fs";
+export class DataExporter {
+    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", "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
+     */
+    async export(inputFile, outputFile, format, options = {}) {
+        return new Promise((resolve, reject) => {
+            if (!fs.existsSync(inputFile)) {
+                reject(new Error(`Input file not found: ${inputFile}`));
+                return;
+            }
+            const args = [this.scriptPath, inputFile, outputFile, format, JSON.stringify(options)];
+            const process = spawn(this.pythonPath, 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(`Export failed: ${stderr || stdout}`));
+                    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 export output: ${stdout}`));
+                }
+            });
+        });
+    }
+}

package/build/export/packager.js

@@ -0,0 +1,100 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+/**
+ * MetadataPackager bundles data files with metadata and quality reports.
+ * Follows a simplified Frictionless Data Package standard.
+ */
+export class MetadataPackager {
+    /**
+     * Creates a data package in the target directory
+     */
+    async createPackage(targetDir, dataFiles, metadata, extraArtifacts) {
+        try {
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+            }
+            const resources = [];
+            // 1. Process Data Files
+            for (const file of dataFiles) {
+                if (!fs.existsSync(file.path)) {
+                    throw new Error(`Data file not found: ${file.path}`);
+                }
+                const fileName = path.basename(file.path);
+                const destPath = path.join(targetDir, fileName);
+                // Copy file to package dir
+                fs.copyFileSync(file.path, destPath);
+                // Compute hash and size
+                const fileBuffer = fs.readFileSync(destPath);
+                const hash = crypto.createHash("sha256").update(fileBuffer).digest("hex");
+                const stats = fs.statSync(destPath);
+                resources.push({
+                    name: file.name,
+                    path: fileName,
+                    format: file.format,
+                    mediatype: this.getMediaType(file.format),
+                    bytes: stats.size,
+                    hash: `sha256:${hash}`
+                });
+            }
+            // 2. Add Extra Artifacts
+            if (extraArtifacts?.qualityReport) {
+                const qrPath = path.join(targetDir, "quality_report.json");
+                fs.writeFileSync(qrPath, JSON.stringify(extraArtifacts.qualityReport, null, 2));
+                resources.push({
+                    name: "quality-report",
+                    path: "quality_report.json",
+                    format: "json"
+                });
+            }
+            if (extraArtifacts?.cleaningLog) {
+                const clPath = path.join(targetDir, "cleaning_log.json");
+                fs.writeFileSync(clPath, JSON.stringify(extraArtifacts.cleaningLog, null, 2));
+                resources.push({
+                    name: "cleaning-log",
+                    path: "cleaning_log.json",
+                    format: "json"
+                });
+            }
+            // 3. Generate Manifest (datapackage.json)
+            const manifest = {
+                profile: "tabular-data-package",
+                name: metadata.name.toLowerCase().replace(/\s+/g, "-"),
+                title: metadata.name,
+                description: metadata.description,
+                version: metadata.version,
+                homepage: "https://github.com/vesper-data",
+                license: metadata.license,
+                author: metadata.author,
+                keywords: metadata.tags,
+                created: new Date().toISOString(),
+                resources: resources
+            };
+            const manifestPath = path.join(targetDir, "datapackage.json");
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+            return {
+                success: true,
+                packagePath: targetDir,
+                manifest: manifest
+            };
+        }
+        catch (e) {
+            return {
+                success: false,
+                packagePath: targetDir,
+                manifest: null,
+                error: e.message
+            };
+        }
+    }
+    getMediaType(format) {
+        switch (format.toLowerCase()) {
+            case "csv": return "text/csv";
+            case "parquet": return "application/x-parquet";
+            case "jsonl": return "application/x-jsonlines";
+            case "arrow": return "application/x-apache-arrow-file";
+            case "json": return "application/json";
+            default: return "application/octet-stream";
+        }
+    }
+}

package/build/export/types.js

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

package/build/fusion/aligner.js

@@ -0,0 +1,56 @@
+export class SchemaAligner {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Finds common columns across datasets and creates a mapping to canonical names.
+     */
+    align(datasets) {
+        const alignment = {};
+        for (const ds of datasets) {
+            alignment[ds.id] = {};
+            if (!ds.columns)
+                continue;
+            for (const col of ds.columns) {
+                const canonicalName = this.getCanonicalName(col.name);
+                if (canonicalName) {
+                    alignment[ds.id][col.name] = canonicalName;
+                }
+            }
+        }
+        return alignment;
+    }
+    /**
+     * Resolves the most specific common type for a canonical column.
+     */
+    resolveType(canonicalName, types) {
+        if (this.config.type_overrides[canonicalName]) {
+            return this.config.type_overrides[canonicalName];
+        }
+        const uniqueTypes = new Set(types.map(t => t.toLowerCase()));
+        if (uniqueTypes.size === 1) {
+            return Array.from(uniqueTypes)[0];
+        }
+        if (uniqueTypes.has("float") || uniqueTypes.has("number")) {
+            return "number";
+        }
+        return "string"; // Default to string for mixed types
+    }
+    getCanonicalName(colName) {
+        // Direct match with any canonical name
+        for (const canonical in this.config.column_aliases) {
+            if (canonical.toLowerCase() === colName.toLowerCase()) {
+                return canonical;
+            }
+            // Match with aliases
+            const aliases = this.config.column_aliases[canonical];
+            if (aliases.some((a) => a.toLowerCase() === colName.toLowerCase())) {
+                return canonical;
+            }
+        }
+        // If no alias, use the name itself if it's already one of the canonical names we expect
+        // This is a bit recursive, let's simplify.
+        return null;
+    }
+}