@vespermcp/mcp-server 1.0.0

package/build/scripts/test-compliance.js

@@ -0,0 +1,58 @@
+import { MetadataStore } from "../metadata/store.js";
+import { ComplianceStore } from "../compliance/store.js";
+import { ComplianceService } from "../compliance/service.js";
+import path from "path";
+import fs from "fs";
+async function runTest() {
+    const dbPath = path.resolve("data", "test-compliance.db");
+    const metadataStore = new MetadataStore(dbPath);
+    const complianceStore = new ComplianceStore(metadataStore.db);
+    const service = new ComplianceService(complianceStore);
+    const dsId = "org/health-data";
+    const medDataset = {
+        id: dsId,
+        source: "huggingface",
+        name: "Patient Records (Mock)",
+        domain: "healthcare",
+        has_personal_data: true,
+        quality_warnings: ["Potential PII detected in column 'patient_name'"],
+        last_updated: new Date().toISOString(),
+        license: { id: "proprietary", category: "restricted", usage_restrictions: [], warnings: [] },
+        // ... rest
+    };
+    console.log("--- Initial Compliance Check (Expecting Failure) ---");
+    const gdpr1 = await service.verifyGDPR(medDataset);
+    console.log(`GDPR Passed: ${gdpr1.passed}`);
+    console.log("Issues:", JSON.stringify(gdpr1.issues, null, 2));
+    const hipaa1 = await service.verifyHIPAA(medDataset);
+    console.log(`HIPAA Passed: ${hipaa1.passed}`);
+    console.log("Issues:", JSON.stringify(hipaa1.issues, null, 2));
+    console.log("\n--- Logging Operations (Audit Trail) ---");
+    service.logOperation("admin-123", dsId, "ComplianceCheck", { result: "Failed" });
+    service.logOperation("admin-123", dsId, "Clean", { rules: "PII-Masking" });
+    console.log("\n--- Resolving Compliance Issues ---");
+    complianceStore.saveConsent({
+        dataset_id: dsId,
+        consent_obtained: true,
+        source: "patient-portal",
+        last_verified: new Date().toISOString()
+    });
+    // Simulate de-identification
+    const cleanDataset = { ...medDataset, has_personal_data: false, quality_warnings: [] };
+    const gdpr2 = await service.verifyGDPR(cleanDataset);
+    console.log(`GDPR Passed (After Fix): ${gdpr2.passed}`);
+    const hipaa2 = await service.verifyHIPAA(cleanDataset);
+    console.log(`HIPAA Passed (After Fix): ${hipaa2.passed}`);
+    console.log("\n--- Exporting Audit Log ---");
+    const csv = service.exportAuditLog(dsId);
+    fs.writeFileSync("compliance-audit.csv", csv);
+    console.log("Audit log saved to compliance-audit.csv");
+    console.log("Log Snippet:\n", csv.split("\n").slice(0, 3).join("\n"));
+    if (gdpr2.passed && hipaa2.passed && csv.includes("Clean")) {
+        console.log("\n✅ Success: Compliance checks and audit trail verified.");
+    }
+    else {
+        console.error("\n❌ Failure: Compliance workflow incomplete.");
+    }
+}
+runTest().catch(console.error);

package/build/scripts/test-conversion.js

@@ -0,0 +1,64 @@
+import { MetadataStore } from "../metadata/store.js";
+import { PipelineExecutor } from "../cleaning/executor.js";
+import { InstallService } from "../install/install-service.js";
+import path from "path";
+import fs from "fs";
+async function runTest() {
+    console.log("--- Testing Format Conversion Export ---");
+    const projectRoot = path.resolve(".");
+    const metadataStore = new MetadataStore(path.join(projectRoot, "data", "metadata.db"));
+    const pipelineExecutor = new PipelineExecutor(projectRoot);
+    const installService = new InstallService(projectRoot, metadataStore);
+    // 1. Create a mock JSON dataset
+    const datasetId = "test/json-dataset";
+    const rawDir = path.join(projectRoot, "data", "raw");
+    if (!fs.existsSync(rawDir))
+        fs.mkdirSync(rawDir, { recursive: true });
+    const jsonPath = path.join(rawDir, "test_data.json");
+    const testData = [
+        { id: 1, name: "Alice", value: 10.5 },
+        { id: 2, name: "Bob", value: 20.1 }
+    ];
+    fs.writeFileSync(jsonPath, JSON.stringify(testData));
+    // Register in local_files
+    metadataStore.registerDownload(datasetId, jsonPath, "completed", fs.statSync(jsonPath).size);
+    // Register in datasets to satisfy inner check
+    metadataStore.saveDataset({
+        id: datasetId,
+        source: "huggingface",
+        name: "Test JSON",
+        description: "A test JSON file",
+        license: { category: "safe", id: "mit", usage_restrictions: [], warnings: [] },
+        last_updated: new Date().toISOString(),
+        quality_score: 80,
+        download_url: "http://example.com",
+        quality_warnings: []
+    });
+    console.log("Mock dataset registered.");
+    // 2. Simulate export_dataset with format="csv"
+    console.log(`Converting ${jsonPath} to CSV...`);
+    const downloadStatus = metadataStore.getDownloadStatus(datasetId);
+    if (!downloadStatus)
+        throw new Error("Dataset not found in DB");
+    let sourcePath = downloadStatus.local_path;
+    const requestedFormat = "csv";
+    const currentExt = path.extname(sourcePath).substring(1).toLowerCase();
+    if (currentExt !== requestedFormat) {
+        console.log(`Mismatch detected. Running pipeline conversion...`);
+        const result = await pipelineExecutor.runPipeline(datasetId, sourcePath, requestedFormat);
+        sourcePath = result.final_output_path;
+    }
+    // 3. Install
+    const targetDir = path.join(projectRoot, "test-conversion-export");
+    const finalPath = await installService.install(datasetId, sourcePath, targetDir);
+    console.log(`✅ Final Export Path: ${finalPath}`);
+    if (finalPath.endsWith(".csv") && fs.existsSync(finalPath)) {
+        const content = fs.readFileSync(finalPath, "utf8");
+        console.log("CSV Content Preview:\n" + content);
+        console.log("\nVERIFICATION_STATUS: ✅ PASS");
+    }
+    else {
+        console.error("\nVERIFICATION_STATUS: ❌ FAIL - Result is not a CSV or file missing");
+    }
+}
+runTest().catch(console.error);

package/build/scripts/test-custom-rules.js

@@ -0,0 +1,58 @@
+import { CleaningPlanner } from "../cleaning/planner.js";
+import { NLP_PRESET, HEALTHCARE_PRESET } from "../cleaning/rules.js";
+import { RuleEvaluator } from "../cleaning/evaluator.js";
+async function runTest() {
+    const planner = new CleaningPlanner();
+    const evaluator = new RuleEvaluator();
+    const mockReport = {
+        row_count: 1000,
+        column_count: 3,
+        duplicate_rows: 0,
+        duplicate_percentage: 0,
+        columns: [
+            { name: "text", type: "Utf8", inferred_type: "String", missing_count: 0, missing_percentage: 0, unique_count: 1000, is_constant: false, is_mixed_type: false },
+            { name: "email", type: "Utf8", inferred_type: "String", missing_count: 0, missing_percentage: 0, unique_count: 1000, is_constant: false, is_mixed_type: false },
+            { name: "date", type: "Utf8", inferred_type: "Date", missing_count: 0, missing_percentage: 0, unique_count: 1000, is_constant: false, is_mixed_type: false }
+        ],
+        warnings: [],
+        schema_warnings: [],
+        overall_score: 90
+    };
+    console.log("--- Testing NLP Preset ---");
+    const nlpPlan = await planner.generatePlan("nlp-ds", mockReport, NLP_PRESET);
+    console.log(`Plan generated with ${nlpPlan.operations.length} operations.`);
+    nlpPlan.operations.forEach((op) => console.log(`- [${op.type}] ${op.reason}`));
+    console.log("\n--- Testing Healthcare Preset ---");
+    const hcPlan = await planner.generatePlan("hc-ds", mockReport, HEALTHCARE_PRESET);
+    console.log(`Plan generated with ${hcPlan.operations.length} operations.`);
+    hcPlan.operations.forEach((op) => console.log(`- [${op.type}] ${op.reason}`));
+    console.log("\n--- Testing RuleEvaluator Logic ---");
+    const record = {
+        text: "Check out https://google.com",
+        email: "user@example.com",
+        date: "2023-01-01"
+    };
+    console.log("Original Record:", JSON.stringify(record));
+    let processed = { ...record };
+    // Apply NLP Rules
+    for (const rule of NLP_PRESET.rules) {
+        if (evaluator.matches(processed, rule.condition)) {
+            processed = evaluator.apply(processed, rule);
+        }
+    }
+    // Apply Healthcare Rules
+    for (const rule of HEALTHCARE_PRESET.rules) {
+        if (evaluator.matches(processed, rule.condition)) {
+            processed = evaluator.apply(processed, rule);
+        }
+    }
+    console.log("Processed Record:", JSON.stringify(processed));
+    if (processed.text === "check out " && processed.email.includes("...")) {
+        console.log("\n✅ Success: Rules correctly applied and record transformed.");
+    }
+    else {
+        console.error("\n❌ Failure: Record transformation mismatch.");
+        console.log("Expected text to be lowercased and URL removed, and email to be masked.");
+    }
+}
+runTest().catch(console.error);

package/build/scripts/test-db-opt.js

@@ -0,0 +1,63 @@
+import { MetadataStore } from "../metadata/store.js";
+async function runTest() {
+    console.log("--- Initializing Database Optimization Test ---");
+    const store = new MetadataStore("data/vesper_test_opt.db");
+    // 1. Check if jobs_archive table exists
+    console.log("Verifying tables and indexes...");
+    // 2. Insert mock jobs (some old, some new)
+    const now = new Date();
+    const oldDate = new Date();
+    oldDate.setDate(now.getDate() - 40); // 40 days ago
+    const jobs = [
+        {
+            id: "job-new-1",
+            type: "clean",
+            status: "completed",
+            priority: 0,
+            progress: 100,
+            status_text: "Done",
+            attempts: 1,
+            max_attempts: 3,
+            created_at: now.toISOString(),
+            updated_at: now.toISOString()
+        },
+        {
+            id: "job-old-1",
+            type: "prepare",
+            status: "completed",
+            priority: 0,
+            progress: 100,
+            status_text: "Archivable",
+            attempts: 1,
+            max_attempts: 3,
+            created_at: oldDate.toISOString(),
+            updated_at: oldDate.toISOString()
+        }
+    ];
+    console.log("Inserting mock jobs...");
+    jobs.forEach(j => store.saveJob(j));
+    // 3. Test Archiving
+    console.log("\n--- Testing Archiving Logic (cutoff 30 days) ---");
+    const archivedCount = store.archiveOldJobs(30);
+    console.log(`Archived ${archivedCount} jobs (indicator).`);
+    // Verify
+    const newJob = store.getJob("job-new-1");
+    const oldJob = store.getJob("job-old-1");
+    if (newJob)
+        console.log("✅ New job remains in active table.");
+    if (!oldJob)
+        console.log("✅ Old job removed from active table.");
+    // Manually check archive via query if possible (not exposed, but we can check if it failed)
+    // 4. Test Optimization
+    console.log("\n--- Testing Maintenance Methods ---");
+    try {
+        store.optimize();
+        console.log("✅ Vacuum and Analyze completed.");
+    }
+    catch (e) {
+        console.error("❌ Optimization failed:", e);
+    }
+    console.log("\n✅ Success: Database optimizations verified.");
+    store.close();
+}
+runTest().catch(console.error);

package/build/scripts/test-export-custom.js

@@ -0,0 +1,33 @@
+import { InstallService } from "../install/install-service.js";
+import { MetadataStore } from "../metadata/store.js";
+import path from "path";
+import fs from "fs";
+async function runTest() {
+    console.log("--- Testing Custom Export Path ---");
+    const projectRoot = path.resolve(".");
+    const metadataStore = new MetadataStore(path.join(projectRoot, "data", "metadata.db"));
+    const installService = new InstallService(projectRoot, metadataStore);
+    // Find a naruto dataset
+    const dataset = metadataStore.db.prepare("SELECT * FROM datasets WHERE name LIKE '%naruto%' LIMIT 1").get();
+    if (!dataset) {
+        console.error("Naruto dataset not found. Please run a search first.");
+        return;
+    }
+    const customDir = path.join(projectRoot, "naruto-quotes");
+    const mockFile = path.join(projectRoot, "data", "raw", "naruto_test_export.csv");
+    if (!fs.existsSync(path.dirname(mockFile))) {
+        fs.mkdirSync(path.dirname(mockFile), { recursive: true });
+    }
+    fs.writeFileSync(mockFile, "quote,character\nBelieve it!,Naruto");
+    console.log(`Exporting ${dataset.id} to ${customDir}...`);
+    const finalPath = await installService.install(dataset.id, mockFile, customDir);
+    console.log(`✅ Success! Exported to: ${finalPath}`);
+    if (fs.existsSync(finalPath) && finalPath.includes("naruto-quotes")) {
+        console.log("Path verification: PASSED");
+    }
+    else {
+        console.error("Path verification: FAILED");
+    }
+    console.log("\n--- Test Complete ---");
+}
+runTest().catch(console.error);

package/build/scripts/test-exporter.js

@@ -0,0 +1,53 @@
+import { DataExporter } from "../export/exporter.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Data Exporter Test ===\n");
+    const exporter = new DataExporter();
+    const testDir = path.join(process.cwd(), "test_export");
+    if (!fs.existsSync(testDir))
+        fs.mkdirSync(testDir);
+    const inputFile = path.join(testDir, "input.csv");
+    // Create Dummy Data
+    let csvContent = "id,name,value\n";
+    for (let i = 0; i < 10; i++)
+        csvContent += `${i},item_${i},${Math.random()}\n`;
+    fs.writeFileSync(inputFile, csvContent);
+    console.log(`Created input file: ${inputFile}`);
+    const formats = ["parquet", "jsonl", "arrow"];
+    for (const fmt of formats) {
+        const outputFile = path.join(testDir, `output.${fmt}`);
+        console.log(`\n--- Exporting to ${fmt.toUpperCase()} ---`);
+        try {
+            const result = await exporter.export(inputFile, outputFile, fmt);
+            console.log("Result:", result);
+            if (fs.existsSync(outputFile)) {
+                const stats = fs.statSync(outputFile);
+                console.log(`PASS: File created (${stats.size} bytes)`);
+            }
+            else {
+                console.error("FAIL: Output file not found");
+            }
+        }
+        catch (e) {
+            console.error(`FAIL: Export to ${fmt} failed:`, e);
+        }
+    }
+    // specific Arrow test
+    // specific TFRecord test (might fail if no tensorflow)
+    console.log(`\n--- Exporting to TFRECORD (Optional) ---`);
+    const tfFile = path.join(testDir, "output.tfrecord");
+    try {
+        const result = await exporter.export(inputFile, tfFile, "tfrecord");
+        console.log("Result:", result);
+        if (fs.existsSync(tfFile)) {
+            console.log("PASS: TFRecord file created");
+        }
+    }
+    catch (e) {
+        console.log("SKIP: TFRecord export failed (likely no tensorflow installed):", e.message || e);
+    }
+    // Cleanup
+    // fs.rmSync(testDir, { recursive: true, force: true });
+}
+main().catch(console.error);

package/build/scripts/test-fusion.js

@@ -0,0 +1,61 @@
+import { FusionOrchestrator } from "../fusion/orchestrator.js";
+import * as fs from "fs";
+async function runTest() {
+    const ds1 = {
+        id: "ds1",
+        name: "Dataset 1",
+        source: "huggingface",
+        columns: [
+            { name: "text", type: "string" },
+            { name: "label", type: "int", is_target: true }
+        ],
+        // ... other required fields (using type assertion for brevity in test)
+    };
+    const ds2 = {
+        id: "ds2",
+        name: "Dataset 2",
+        source: "kaggle",
+        columns: [
+            { name: "sentence", type: "string" },
+            { name: "sentiment", type: "string", is_target: true }
+        ],
+    };
+    const config = {
+        target_column: "target",
+        column_aliases: {
+            "text": ["sentence", "content"],
+            "target": ["label", "sentiment", "target"]
+        },
+        type_overrides: {},
+        dedupe_config: {
+            exact: true,
+            fuzzy: true,
+            fuzzy_threshold: 0.6,
+            fuzzy_columns: ["text"]
+        },
+        label_map: {
+            "pos": 1,
+            "neg": 0,
+            "0": 0,
+            "1": 1
+        }
+    };
+    const records = [
+        { datasetId: "ds1", record: { text: "I love this!", label: 1 } },
+        { datasetId: "ds1", record: { text: "This is bad.", label: 0 } },
+        { datasetId: "ds2", record: { sentence: "I love this!", sentiment: "pos" } }, // Exact duplicate (after alignment)
+        { datasetId: "ds2", record: { sentence: "I really love this!", sentiment: "pos" } }, // Fuzzy duplicate
+        { datasetId: "ds2", record: { sentence: "It was okay.", sentiment: "neg" } },
+    ];
+    const orchestrator = new FusionOrchestrator(config);
+    const result = await orchestrator.fuse([ds1, ds2], records);
+    fs.writeFileSync("test-fusion-results.json", JSON.stringify(result, null, 2));
+    console.log("Results written to test-fusion-results.json");
+    if (result.stats.total_output_rows === 3) {
+        console.log("✅ Success: Rows correctly fused and deduplicated.");
+    }
+    else {
+        console.error(`❌ Failure: Expected 3 rows, got ${result.stats.total_output_rows}`);
+    }
+}
+runTest().catch(console.error);

package/build/scripts/test-github.js

@@ -0,0 +1,27 @@
+import { GitHubScraper } from "../metadata/github-scraper.js";
+async function runTest() {
+    console.log("--- Testing GitHub integration ---");
+    const scraper = new GitHubScraper();
+    const query = "covid-19";
+    console.log(`Searching GitHub for: "${query}"...`);
+    const results = await scraper.scrape(query, 5);
+    console.log(`Found ${results.length} datasets.`);
+    if (results.length > 0) {
+        console.log("✅ GitHub Scraper returned results.");
+        console.log("Sample Result:");
+        console.log(JSON.stringify(results[0], null, 2));
+        // Validation
+        const sample = results[0];
+        if (sample.id.startsWith("github:") && sample.source === "github") {
+            console.log("✅ Metadata schema validation passed.");
+        }
+        else {
+            console.error("❌ Metadata schema validation failed.");
+        }
+    }
+    else {
+        console.error("❌ No results found or rate limit hit.");
+    }
+    console.log("--- Test Complete ---");
+}
+runTest().catch(console.error);

package/build/scripts/test-group-split.js

@@ -0,0 +1,52 @@
+import { DataSplitter } from "../splitting/splitter.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Group Split Test ===\n");
+    const splitter = new DataSplitter();
+    const testFile = path.join(process.cwd(), "test_group_split.csv");
+    // Create Dummy Data (100 rows, 10 groups of 10 rows each)
+    let csvContent = "id,group_id,value\n";
+    for (let g = 0; g < 10; g++) {
+        for (let i = 0; i < 10; i++) {
+            csvContent += `${g * 10 + i},group_${g},${Math.random()}\n`;
+        }
+    }
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created test file with 10 distinct groups.`);
+    // Test: Group-based Split (60/20/20)
+    const config = {
+        type: "group",
+        ratios: { train: 0.6, val: 0.2, test: 0.2, holdout: 0 },
+        group_column: "group_id",
+        shuffle: true,
+        random_seed: 42
+    };
+    try {
+        const result = await splitter.split(testFile, config);
+        console.log("Stats:", result.stats);
+        // Validation: No group should exist in more than one split
+        console.log("\n--- Group Leakage Validation ---");
+        const report = await splitter.validate(result.paths, { id_column: "group_id" }); // Checking uniqueness of group_id across splits
+        console.log("Validation Report:", report);
+        if (!report.leakage_detected) {
+            console.log("PASS: No group leakage detected.");
+        }
+        else {
+            console.error("FAIL: Groups leaked across splits!");
+        }
+        // Cleanup
+        Object.values(result.paths).forEach(p => {
+            if (fs.existsSync(p))
+                fs.unlinkSync(p);
+        });
+    }
+    catch (e) {
+        console.error("Test execution failed:", e);
+    }
+    finally {
+        if (fs.existsSync(testFile))
+            fs.unlinkSync(testFile);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-hf-download.js

@@ -0,0 +1,29 @@
+import { HFDownloader } from "../ingestion/hf-downloader.js";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.join(__dirname, "..", "..");
+async function testHFDownload() {
+    const downloader = new HFDownloader();
+    const repoId = "fka/awesome-chatgpt-prompts";
+    console.log(`Testing HF Download for ${repoId}...`);
+    const bestFile = await downloader.findBestFile(repoId);
+    console.log(`Best file found: ${bestFile}`);
+    if (bestFile) {
+        const testDir = path.join(projectRoot, "data", "test");
+        if (!fs.existsSync(testDir))
+            fs.mkdirSync(testDir, { recursive: true });
+        const targetPath = path.join(testDir, "awesome-prompts.csv");
+        await downloader.download(repoId, bestFile, targetPath, (p) => {
+            process.stdout.write(`\rProgress: ${p}%`);
+        });
+        console.log(`\nDownload complete! Size: ${fs.statSync(targetPath).size} bytes`);
+        console.log(`Location: ${targetPath}`);
+    }
+    else {
+        console.error("No file found!");
+    }
+}
+testHFDownload().catch(console.error);

package/build/scripts/test-holdout-manager.js

@@ -0,0 +1,61 @@
+import { DataSplitter } from "../splitting/splitter.js";
+import fs from "fs";
+import path from "path";
+async function main() {
+    console.log("=== Vesper Holdout Set Manager Test ===\n");
+    const splitter = new DataSplitter();
+    const testFile = path.join(process.cwd(), "test_holdout.csv");
+    // Create Dummy Data (200 rows)
+    let csvContent = "id,label,date\n";
+    for (let i = 0; i < 100; i++)
+        csvContent += `${i},A,2023-01-${(i % 30) + 1}\n`;
+    for (let i = 100; i < 200; i++)
+        csvContent += `${i},B,2023-02-${(i % 28) + 1}\n`;
+    fs.writeFileSync(testFile, csvContent);
+    console.log(`Created test file: ${testFile}`);
+    // Test: 4-way Random Split (70/10/10/10)
+    console.log("\n--- Test: 4-way Random Split (70/10/10/10) ---");
+    const config = {
+        type: "random",
+        ratios: { train: 0.7, val: 0.1, test: 0.1, holdout: 0.1 },
+        shuffle: true,
+        random_seed: 42
+    };
+    try {
+        const result = await splitter.split(testFile, config);
+        console.log("Stats:", result.stats);
+        const expected = { train: 140, val: 20, test: 20, holdout: 20 };
+        if (result.stats.train_rows === expected.train &&
+            result.stats.val_rows === expected.val &&
+            result.stats.test_rows === expected.test &&
+            result.stats.holdout_rows === expected.holdout) {
+            console.log("PASS: 4-way ratios preserved");
+        }
+        else {
+            console.error(`FAIL: Ratios mismatch. Expected ${JSON.stringify(expected)}, got ${JSON.stringify(result.stats)}`);
+        }
+        // Validate Split for Leakage
+        console.log("\n--- Validation Check ---");
+        const report = await splitter.validate(result.paths, { id_column: "id" });
+        console.log("Report:", report);
+        if (!report.leakage_detected) {
+            console.log("PASS: No leakage between 4 splits");
+        }
+        else {
+            console.error("FAIL: Leakage detected!");
+        }
+        // Cleanup
+        Object.values(result.paths).forEach(p => {
+            if (fs.existsSync(p))
+                fs.unlinkSync(p);
+        });
+    }
+    catch (e) {
+        console.error("Test execution failed:", e);
+    }
+    finally {
+        if (fs.existsSync(testFile))
+            fs.unlinkSync(testFile);
+    }
+}
+main().catch(console.error);

package/build/scripts/test-hybrid-search.js

@@ -0,0 +1,41 @@
+import { SearchEngine } from "../search/engine.js";
+import { MetadataStore } from "../metadata/store.js";
+import { VectorStore } from "../search/vector-store.js";
+import { Embedder } from "../search/embedder.js";
+import path from "path";
+async function main() {
+    const dbPath = path.join(process.cwd(), "data", "metadata.db");
+    const vectorPath = path.join(process.cwd(), "data", "vectors.json");
+    const store = new MetadataStore(dbPath);
+    const vectorStore = new VectorStore(vectorPath);
+    const embedder = Embedder.getInstance();
+    await embedder.init();
+    const engine = new SearchEngine(store, vectorStore, embedder);
+    console.log("\n=== Hybrid Search Precision Test ===\n");
+    // Test 1: Financial Forecasting (Drift Check)
+    // Should NOT have crypto in top results if hybrid logic works
+    console.log("Test 1: 'financial forecasting' (Should penalize Crypto)");
+    const results1 = await engine.search("financial forecasting", { limit: 5 });
+    results1.forEach((r, i) => {
+        const score = r.relevance_score;
+        const vector = r.vector_score;
+        const lexical = r.lexical_score;
+        console.log(`  ${i + 1}. [${score}] ${r.name} (Vec: ${vector}, Lex: ${lexical})`);
+        if (r.name.toLowerCase().includes("crypto") || r.description.toLowerCase().includes("bitcoin")) {
+            console.error("     CRITICAL: Crypto found in top results!");
+        }
+    });
+    console.log("");
+    // Test 2: Negative Keywords
+    console.log("Test 2: 'financial forecasting -stock' (Should exclude 'stock')");
+    const results2 = await engine.search("financial forecasting -stock", { limit: 5 });
+    results2.forEach((r, i) => {
+        console.log(`  ${i + 1}. ${r.name}`);
+        if (r.name.toLowerCase().includes("stock") || r.description.toLowerCase().includes("stock")) {
+            console.error("     ERROR: Negative keyword failed!");
+        }
+    });
+    console.log("\nDone.");
+    store.close();
+}
+main().catch(console.error);

package/build/scripts/test-image-analysis.js

@@ -0,0 +1,50 @@
+import { ImageAnalyzer } from "../quality/image-analyzer.js";
+import path from "path";
+import fs from "fs";
+import { execSync } from "child_process";
+async function runTest() {
+    console.log("--- Testing Image Quality Analysis ---");
+    const projectRoot = path.resolve(".");
+    const analyzer = new ImageAnalyzer(projectRoot);
+    // 1. Create a sample image using Python (to avoid external dependencies)
+    const testImageDir = path.join(projectRoot, "data", "test-images");
+    if (!fs.existsSync(testImageDir))
+        fs.mkdirSync(testImageDir, { recursive: true });
+    const imagePath = path.join(testImageDir, "test_v1.png");
+    console.log("Generating test image...");
+    const pythonScript = `
+from PIL import Image, ImageDraw
+import numpy as np
+img = Image.new('RGB', (800, 600), color = (73, 109, 137))
+d = ImageDraw.Draw(img)
+d.text((10,10), "Vesper Test Image", fill=(255,255,0))
+# Add some noise for blur check
+noise = np.random.randint(0, 255, (600, 800, 3), dtype='uint8')
+img_np = np.array(img)
+img_np = (img_np * 0.5 + noise * 0.5).astype('uint8')
+Image.fromarray(img_np).save('${imagePath.replace(/\\/g, "\\\\")}')
+    `;
+    fs.writeFileSync(path.join(testImageDir, "gen_image.py"), pythonScript);
+    execSync(`python "${path.join(testImageDir, "gen_image.py")}"`);
+    // 2. Run Analysis
+    console.log(`Analyzing ${imagePath}...`);
+    try {
+        const report = await analyzer.analyze(imagePath);
+        console.log("Analysis Result:");
+        console.log(`- Format: ${report.individual_results[0].format}`);
+        console.log(`- Resolution: ${report.individual_results[0].width}x${report.individual_results[0].height}`);
+        console.log(`- Blur Score: ${report.individual_results[0].blur_score}`);
+        console.log(`- Is Blurry: ${report.individual_results[0].is_blurry}`);
+        if (report.total_images === 1 && report.average_width === 800) {
+            console.log("\nVERIFICATION_STATUS: PASS");
+        }
+        else {
+            console.log("\nVERIFICATION_STATUS: FAIL - Incorrect stats");
+        }
+    }
+    catch (e) {
+        console.error(`Analysis failed: ${e.message}`);
+        console.log("\nVERIFICATION_STATUS: FAIL");
+    }
+}
+runTest().catch(console.error);