vesper-wizard 2.3.1 → 2.3.3

package/build/compliance/service.js

@@ -1,73 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-export class ComplianceService {
-    store;
-    constructor(store) {
-        this.store = store;
-    }
-    async verifyGDPR(dataset) {
-        const issues = [];
-        // 1. Check for PII metadata flag
-        if (dataset.has_personal_data) {
-            issues.push("Dataset explicitly flagged as containing personal data.");
-        }
-        // 2. Check quality warnings for PII
-        if (dataset.quality_warnings) {
-            const piiWarnings = dataset.quality_warnings.filter(w => w.toLowerCase().includes("pii") || w.toLowerCase().includes("personal"));
-            if (piiWarnings.length > 0) {
-                issues.push(...piiWarnings);
-            }
-        }
-        // 3. Check for consent record
-        const consent = this.store.getConsent(dataset.id);
-        if (!consent || !consent.consent_obtained) {
-            issues.push("No valid consent record found for this dataset.");
-        }
-        const result = {
-            dataset_id: dataset.id,
-            standard: "GDPR",
-            passed: issues.length === 0,
-            issues,
-            timestamp: new Date().toISOString()
-        };
-        this.store.saveCheck(result);
-        return result;
-    }
-    async verifyHIPAA(dataset) {
-        const issues = [];
-        // 1. De-identification check (simulated)
-        // If domain is medical but no de-identification flag exists
-        if (dataset.domain === "healthcare" || dataset.domain === "medical") {
-            if (dataset.has_personal_data) {
-                issues.push("Medical dataset contains personal data (not de-identified).");
-            }
-        }
-        const result = {
-            dataset_id: dataset.id,
-            standard: "HIPAA",
-            passed: issues.length === 0,
-            issues,
-            timestamp: new Date().toISOString()
-        };
-        this.store.saveCheck(result);
-        return result;
-    }
-    logOperation(userId, datasetId, operation, metadata = {}) {
-        const event = {
-            id: uuidv4(),
-            user_id: userId,
-            dataset_id: datasetId,
-            operation,
-            timestamp: new Date().toISOString(),
-            details: JSON.stringify(metadata)
-        };
-        this.store.saveAudit(event);
-    }
-    exportAuditLog(datasetId) {
-        const logs = this.store.getAuditLogs(datasetId);
-        if (logs.length === 0)
-            return "No audit logs found.";
-        const header = "ID,Timestamp,User,Operation,Dataset,Details\n";
-        const rows = logs.map(l => `${l.id},${l.timestamp},${l.user_id},${l.operation},${l.dataset_id},"${l.details.replace(/"/g, '""')}"`).join("\n");
-        return header + rows;
-    }
-}

package/build/compliance/store.js

@@ -1,80 +0,0 @@
-export class ComplianceStore {
-    db;
-    constructor(db) {
-        this.db = db;
-        this.init();
-    }
-    init() {
-        this.db.exec(`
-            CREATE TABLE IF NOT EXISTS audit_logs (
-                id TEXT PRIMARY KEY,
-                user_id TEXT,
-                dataset_id TEXT,
-                operation TEXT,
-                timestamp TEXT,
-                details TEXT
-            );
-
-            CREATE TABLE IF NOT EXISTS compliance_checks (
-                dataset_id TEXT,
-                standard TEXT,
-                passed BOOLEAN,
-                issues TEXT, -- JSON array
-                timestamp TEXT,
-                PRIMARY KEY (dataset_id, standard)
-            );
-
-            CREATE TABLE IF NOT EXISTS consent_records (
-                dataset_id TEXT PRIMARY KEY,
-                consent_obtained BOOLEAN,
-                source TEXT,
-                last_verified TEXT
-            );
-        `);
-    }
-    saveAudit(event) {
-        const stmt = this.db.prepare(`
-            INSERT INTO audit_logs (id, user_id, dataset_id, operation, timestamp, details)
-            VALUES (?, ?, ?, ?, ?, ?)
-        `);
-        stmt.run(event.id, event.user_id, event.dataset_id, event.operation, event.timestamp, event.details);
-    }
-    getAuditLogs(datasetId) {
-        let query = "SELECT * FROM audit_logs";
-        const params = [];
-        if (datasetId) {
-            query += " WHERE dataset_id = ?";
-            params.push(datasetId);
-        }
-        query += " ORDER BY timestamp DESC";
-        return this.db.prepare(query).all(...params);
-    }
-    saveCheck(result) {
-        const stmt = this.db.prepare(`
-            INSERT INTO compliance_checks (dataset_id, standard, passed, issues, timestamp)
-            VALUES (?, ?, ?, ?, ?)
-            ON CONFLICT(dataset_id, standard) DO UPDATE SET
-                passed=excluded.passed,
-                issues=excluded.issues,
-                timestamp=excluded.timestamp
-        `);
-        stmt.run(result.dataset_id, result.standard, result.passed ? 1 : 0, JSON.stringify(result.issues), result.timestamp);
-    }
-    saveConsent(record) {
-        const stmt = this.db.prepare(`
-            INSERT INTO consent_records (dataset_id, consent_obtained, source, last_verified)
-            VALUES (?, ?, ?, ?)
-            ON CONFLICT(dataset_id) DO UPDATE SET
-                consent_obtained=excluded.consent_obtained,
-                source=excluded.source,
-                last_verified=excluded.last_verified
-        `);
-        stmt.run(record.dataset_id, record.consent_obtained ? 1 : 0, record.source, record.last_verified);
-    }
-    getConsent(datasetId) {
-        const row = this.db.prepare("SELECT * FROM consent_records WHERE dataset_id = ?").get(datasetId);
-        if (!row)
-            return null;
-        return { ...row, consent_obtained: Boolean(row.consent_obtained) };
-    }
-}

package/build/compliance/types.js

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

package/build/config/config-manager.js

@@ -1,221 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,82 +0,0 @@
-import { spawn } from "child_process";
-import path from "path";
-import fs from "fs";
-import { ensurePythonPackages, resolvePythonCommand } from "../utils/python-runtime.js";
-export class DataExporter {
-    buildDir;
-    scriptPath;
-    constructor(buildDir = process.cwd()) {
-        this.buildDir = buildDir;
-        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;
-        }
-    }
-    /**
-     * Exports a dataset file to a specified format
-     */
-    async export(inputFile, outputFile, format, options = {}) {
-        const pythonRequirements = [
-            { module: "polars", packageName: "polars" },
-        ];
-        if (format === "feather") {
-            pythonRequirements.push({ module: "pyarrow", packageName: "pyarrow" });
-        }
-        if (format === "tfrecord") {
-            pythonRequirements.push({ module: "tensorflow", packageName: "tensorflow" });
-        }
-        const pythonPath = await ensurePythonPackages(this.buildDir, pythonRequirements).catch(() => resolvePythonCommand(this.buildDir));
-        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 childProcess = spawn(pythonPath, args, {
-                env: {
-                    ...process.env,
-                    PYTHONIOENCODING: "utf-8",
-                },
-            });
-            let stdout = "";
-            let stderr = "";
-            childProcess.stdout.on("data", (data) => stdout += data.toString());
-            childProcess.stderr.on("data", (data) => stderr += data.toString());
-            childProcess.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}`));
-                }
-            });
-        });
-    }
-}