@vespermcp/mcp-server 1.0.0

package/build/index.js

@@ -0,0 +1,632 @@
+#! /usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ErrorCode, McpError, } from "@modelcontextprotocol/sdk/types.js";
+import { fileURLToPath } from "url";
+import path from "path";
+import fs from "fs";
+import { MetadataStore } from "./metadata/store.js";
+import { VectorStore } from "./search/vector-store.js";
+import { Embedder } from "./search/embedder.js";
+import { SearchEngine } from "./search/engine.js";
+import { formatSearchResults, formatDatasetInfo, formatJobStatus } from "./tools/formatter.js";
+import { JobManager } from "./jobs/manager.js";
+import { QualityAnalyzer } from "./quality/analyzer.js";
+import { CleaningPlanner } from "./cleaning/planner.js";
+import { DataCleaner } from "./cleaning/cleaner.js";
+import { PipelineExecutor } from "./cleaning/executor.js";
+import { DataSplitter } from "./splitting/splitter.js";
+import { DataExporter } from "./export/exporter.js";
+import { DataIngestor } from "./ingestion/ingestor.js";
+import { InstallService } from "./install/install-service.js";
+import { CacheService, MockRedisProvider } from "./cache/service.js";
+import { ImageAnalyzer } from "./quality/image-analyzer.js";
+import { MediaAnalyzer } from "./quality/media-analyzer.js";
+import { QualityOrchestrator } from "./quality/quality-orchestrator.js";
+// Determine absolute paths relative to the compiled script
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// We are in /build/index.js, so project root is one level up
+const projectRoot = path.join(__dirname, "..");
+const dbPath = path.join(projectRoot, "data", "metadata.db");
+const vectorPath = path.join(projectRoot, "data", "vectors.json");
+const metadataStore = new MetadataStore(dbPath);
+const vectorStore = new VectorStore(vectorPath);
+const embedder = Embedder.getInstance();
+const searchEngine = new SearchEngine(metadataStore, vectorStore, embedder);
+const jobManager = JobManager.getInstance(metadataStore);
+const dataIngestor = new DataIngestor(projectRoot, metadataStore);
+const installService = new InstallService(projectRoot, metadataStore);
+const cacheService = new CacheService(new MockRedisProvider());
+const qualityAnalyzer = new QualityAnalyzer(cacheService, projectRoot);
+const cleaningPlanner = new CleaningPlanner(cacheService);
+const dataCleaner = new DataCleaner(projectRoot);
+const pipelineExecutor = new PipelineExecutor(projectRoot);
+const dataSplitter = new DataSplitter(projectRoot);
+const dataExporter = new DataExporter(projectRoot);
+const imageAnalyzer = new ImageAnalyzer(projectRoot);
+const mediaAnalyzer = new MediaAnalyzer(projectRoot);
+const qualityOrchestrator = new QualityOrchestrator(projectRoot);
+// Subscribe to job updates for real-time streaming to the UI
+jobManager.on("jobUpdated", (job) => {
+    const level = job.status === "failed" ? "error" : "info";
+    const emoji = job.status === "completed" ? "✅" : (job.status === "failed" ? "❌" : "⏳");
+    const progress = job.progress > 0 ? `[${job.progress}%]` : "";
+    server.sendLoggingMessage({
+        level,
+        data: `${emoji} [Job ${job.id.substring(0, 8)}] ${progress} ${job.status_text}`
+    });
+});
+// Create the server
+const server = new Server({
+    name: "vesper",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+        logging: {},
+    },
+});
+// List Tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "vesper_search",
+                description: "Search for datasets using natural language. Supports negative keywords (e.g., 'finance -crypto'). Returns formatted results with safety indicators, quality warnings, and source badges.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "The search query. Use -term to exclude keywords.",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "get_dataset_info",
+                description: "Get detailed metadata for a specific dataset by its ID. Returns comprehensive information including license, safety flags, and data characteristics.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dataset_id: {
+                            type: "string",
+                            description: "The unique dataset ID (e.g., 'user/dataset_name' for HuggingFace or 'kaggle:username/dataset' for Kaggle)",
+                        },
+                    },
+                    required: ["dataset_id"],
+                },
+            },
+            {
+                name: "analyze_quality",
+                description: "Perform a deep quality check on a dataset. Returns a detailed report including duplicates, outliers, and schema issues.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dataset_id: {
+                            type: "string",
+                            description: "The dataset ID to analyze.",
+                        },
+                    },
+                    required: ["dataset_id"],
+                },
+            },
+            {
+                name: "preview_cleaning",
+                description: "Dry-run of the cleaning plan. Shows what WOULD be cleaned without modifying data.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dataset_id: {
+                            type: "string",
+                            description: "The dataset ID to preview cleaning for.",
+                        },
+                    },
+                    required: ["dataset_id"],
+                },
+            },
+            {
+                name: "custom_clean",
+                description: "Apply specific cleaning operations to a dataset as an asynchronous job.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dataset_id: {
+                            type: "string",
+                            description: "The dataset ID to clean.",
+                        },
+                        operations: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    type: { type: "string" },
+                                    params: { type: "object" },
+                                    reason: { type: "string" },
+                                },
+                            },
+                        },
+                    },
+                    required: ["dataset_id", "operations"],
+                },
+            },
+            {
+                name: "prepare_dataset",
+                description: "Full pipeline: Analyze, Clean, Split, and Export as an asynchronous job.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                        requirements: { type: "string" },
+                        cleaning_options: { type: "object" },
+                        split_config: { type: "object" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "compare_datasets",
+                description: "Compare 2-3 datasets side-by-side.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dataset_ids: {
+                            type: "array",
+                            items: { type: "string" },
+                        },
+                    },
+                    required: ["dataset_ids"],
+                },
+            },
+            {
+                name: "check_job_status",
+                description: "Check the status of an asynchronous job.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        job_id: { type: "string" },
+                    },
+                    required: ["job_id"],
+                },
+            },
+            {
+                name: "export_dataset",
+                description: "Export an ingested or prepared dataset to a specific local directory.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dataset_id: {
+                            type: "string",
+                            description: "The unique dataset ID.",
+                        },
+                        target_dir: {
+                            type: "string",
+                            description: "Optional custom local directory for export (e.g., './naruto-quotes').",
+                        },
+                        format: {
+                            type: "string",
+                            enum: ["csv", "parquet"],
+                            description: "Desired output format (default: csv).",
+                        },
+                    },
+                    required: ["dataset_id"],
+                },
+            },
+            {
+                name: "analyze_image_quality",
+                description: "Analyze image quality (resolution, blur, corruption) for a folder or single image.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the image file or folder.",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "analyze_media_quality",
+                description: "Analyze audio/video quality (sample rate, duration, FPS, corruption) for a folder or single file.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Absolute path to the audio/video file or folder.",
+                        },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "generate_quality_report",
+                description: "Generate a comprehensive unified quality report for a multimodal dataset (text, image, audio, video).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        dataset_id: {
+                            type: "string",
+                            description: "Dataset identifier.",
+                        },
+                        dataset_path: {
+                            type: "string",
+                            description: "Absolute path to the dataset directory.",
+                        },
+                    },
+                    required: ["dataset_id", "dataset_path"],
+                },
+            },
+        ],
+    };
+});
+// Call Tool
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    switch (request.params.name) {
+        case "vesper_search": {
+            const query = String(request.params.arguments?.query);
+            const limit = 5;
+            const safeOnly = true; // Enable safe filter by default
+            if (!query) {
+                throw new McpError(ErrorCode.InvalidParams, "Query is required");
+            }
+            const results = await searchEngine.search(query, { limit, safeOnly });
+            const formattedOutput = formatSearchResults(results);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formattedOutput,
+                    },
+                ],
+            };
+        }
+        case "get_dataset_info": {
+            const datasetId = String(request.params.arguments?.dataset_id);
+            if (!datasetId) {
+                throw new McpError(ErrorCode.InvalidParams, "dataset_id is required");
+            }
+            const dataset = metadataStore.getDataset(datasetId);
+            if (!dataset) {
+                return {
+                    content: [{ type: "text", text: `ERROR: Dataset not found: ${datasetId}` }],
+                    isError: true,
+                };
+            }
+            const formattedOutput = formatDatasetInfo(dataset);
+            return { content: [{ type: "text", text: formattedOutput }] };
+        }
+        case "analyze_quality": {
+            const datasetId = String(request.params.arguments?.dataset_id);
+            let filePath = path.join(projectRoot, "data", "raw", `${datasetId.replace(/\//g, "_")}.csv`);
+            // Demo Fallback for easy testing
+            if (datasetId === "demo" || !fs.existsSync(filePath)) {
+                const demoPath = path.join(projectRoot, "e2e_demo_output", "raw_data.csv");
+                if (fs.existsSync(demoPath)) {
+                    filePath = demoPath;
+                }
+                else if (datasetId !== "demo") {
+                    return {
+                        content: [{ type: "text", text: `ERROR: Local data file for ${datasetId} not found. Try running prepare_dataset first, or use 'demo' as the dataset_id.` }],
+                        isError: true
+                    };
+                }
+            }
+            const report = await qualityAnalyzer.analyze(filePath);
+            return {
+                content: [{ type: "text", text: JSON.stringify(report, null, 2) }]
+            };
+        }
+        case "preview_cleaning": {
+            const datasetId = String(request.params.arguments?.dataset_id);
+            let filePath = path.join(projectRoot, "data", "raw", `${datasetId.replace(/\//g, "_")}.csv`);
+            if (datasetId === "demo" || !fs.existsSync(filePath)) {
+                const demoPath = path.join(projectRoot, "e2e_demo_output", "raw_data.csv");
+                if (fs.existsSync(demoPath)) {
+                    filePath = demoPath;
+                }
+                else {
+                    throw new McpError(ErrorCode.InvalidParams, `Local data file not found for ${datasetId}. Please run prepare_dataset first.`);
+                }
+            }
+            const report = await qualityAnalyzer.analyze(filePath);
+            const plan = await cleaningPlanner.generatePlan(datasetId, report);
+            let explanation = `### 📋 Cleaning Plan for ${datasetId}\n\n`;
+            explanation += `Estimated Quality Improvement: +${plan.estimated_impact.quality_score_improvement} points\n\n`;
+            if (plan.operations.length === 0) {
+                explanation += "✅ No cleaning operations required.";
+            }
+            else {
+                plan.operations.forEach((op, i) => {
+                    explanation += `${i + 1}. **${op.type}**: ${op.reason}\n`;
+                });
+            }
+            return {
+                content: [{ type: "text", text: explanation }]
+            };
+        }
+        case "custom_clean": {
+            const datasetId = String(request.params.arguments?.dataset_id);
+            const ops = request.params.arguments?.operations;
+            let filePath = path.join(projectRoot, "data", "raw", `${datasetId.replace(/\//g, "_")}.csv`);
+            if (datasetId === "demo" || !fs.existsSync(filePath)) {
+                const demoPath = path.join(projectRoot, "e2e_demo_output", "raw_data.csv");
+                if (fs.existsSync(demoPath)) {
+                    filePath = demoPath;
+                }
+                else {
+                    throw new McpError(ErrorCode.InvalidParams, `Local data file not found for ${datasetId}`);
+                }
+            }
+            const job = jobManager.createJob("clean", 0, { datasetId, ops });
+            // Run in background
+            jobManager.runJob(job.id, async (update) => {
+                update({ status_text: "Cleaning dataset..." });
+                const result = await dataCleaner.clean(filePath, ops);
+                if (!result.success)
+                    throw new Error(result.error);
+                return result.output_path;
+            });
+            return {
+                content: [{ type: "text", text: `Job started successfully. ID: ${job.id}. Use check_job_status to monitor progress.` }]
+            };
+        }
+        case "prepare_dataset": {
+            const query = String(request.params.arguments?.query);
+            const job = jobManager.createJob("prepare", 0, { query });
+            // Orchestrated Background Task
+            jobManager.runJob(job.id, async (update) => {
+                update({ progress: 10, status_text: "Searching for best dataset matching query..." });
+                const results = await searchEngine.search(query, { limit: 1 });
+                if (results.length === 0)
+                    throw new Error("No datasets found matching the query.");
+                const topDataset = results[0];
+                // Phase 6: Real Ingestion
+                update({
+                    progress: 20,
+                    status_text: `Matched: ${topDataset.name} (${topDataset.source})`
+                });
+                const source = topDataset.source;
+                const filePath = await dataIngestor.ensureData(topDataset.id, source, (msg, prog) => {
+                    update({
+                        status_text: msg,
+                        progress: prog !== undefined ? 20 + Math.floor(prog * 0.3) : undefined // 20% -> 50%
+                    });
+                });
+                update({ progress: 55, status_text: "Analyzing dataset quality..." });
+                const quality = await qualityAnalyzer.analyze(filePath);
+                const pipelineResult = await pipelineExecutor.runPipeline(topDataset.id, filePath, "csv", (msg) => {
+                    update({ status_text: msg });
+                });
+                update({ progress: 90, status_text: "Installing dataset into codebase..." });
+                const installPath = await installService.install(topDataset.id, pipelineResult.final_output_path);
+                update({ progress: 100, status_text: "Preparation complete!" });
+                const message = `✅ Preparation complete for ${topDataset.name}.\n` +
+                    `📦 Dataset installed to: ${installPath}\n` +
+                    `🚀 You can now use this dataset for training your models.`;
+                return message;
+            });
+            return {
+                content: [{ type: "text", text: `Autonomous preparation job started. ID: ${job.id}. Use check_job_status to monitor progress.` }]
+            };
+        }
+        case "compare_datasets": {
+            const datasetIds = request.params.arguments?.dataset_ids;
+            const datasets = datasetIds.map(id => metadataStore.getDataset(id)).filter(d => !!d);
+            let comparison = "| Metric | " + datasets.map(d => d.name).join(" | ") + " |\n";
+            comparison += "| :--- | " + datasets.map(() => " :---: ").join("|") + " |\n";
+            comparison += "| Quality Score | " + datasets.map(d => `${d.quality_score}/100`).join(" | ") + " |\n";
+            comparison += "| License | " + datasets.map(d => d.license.category).join(" | ") + " |\n";
+            comparison += "| Downloads | " + datasets.map(d => d.downloads).join(" | ") + " |\n";
+            comparison += "| Domain | " + datasets.map(d => d.domain).join(" | ") + " |\n";
+            return {
+                content: [{ type: "text", text: comparison }]
+            };
+        }
+        case "check_job_status": {
+            const jobId = String(request.params.arguments?.job_id);
+            const job = metadataStore.getJob(jobId);
+            if (!job) {
+                throw new McpError(ErrorCode.InvalidParams, `Job not found: ${jobId}`);
+            }
+            return {
+                content: [{ type: "text", text: formatJobStatus(job) }]
+            };
+        }
+        case "export_dataset": {
+            const datasetId = String(request.params.arguments?.dataset_id);
+            const targetDir = request.params.arguments?.target_dir ? String(request.params.arguments?.target_dir) : undefined;
+            const requestedFormat = request.params.arguments?.format || "csv";
+            const dataset = metadataStore.getDataset(datasetId);
+            if (!dataset) {
+                throw new McpError(ErrorCode.InvalidParams, `Dataset not found: ${datasetId}`);
+            }
+            // Use Metadata to find the actual local file
+            const downloadStatus = metadataStore.getDownloadStatus(datasetId);
+            if (!downloadStatus || !fs.existsSync(downloadStatus.local_path)) {
+                return {
+                    content: [{ type: "text", text: `ERROR: No local data found for ${datasetId}. Please run prepare_dataset first.` }],
+                    isError: true
+                };
+            }
+            let sourcePath = downloadStatus.local_path;
+            // Check if we need conversion
+            const currentExt = path.extname(sourcePath).substring(1).toLowerCase();
+            if (currentExt !== requestedFormat) {
+                console.log(`[Export] Format mismatch (${currentExt} vs ${requestedFormat}). Converting...`);
+                try {
+                    const pipelineResult = await pipelineExecutor.runPipeline(datasetId, sourcePath, requestedFormat);
+                    sourcePath = pipelineResult.final_output_path;
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: "text", text: `ERROR: Failed to convert dataset to ${requestedFormat}: ${err.message}` }],
+                        isError: true
+                    };
+                }
+            }
+            try {
+                const finalPath = await installService.install(datasetId, sourcePath, targetDir);
+                return {
+                    content: [{ type: "text", text: `✅ Dataset ${datasetId} exported to: ${finalPath}` }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `ERROR: Export failed: ${error.message}` }],
+                    isError: true
+                };
+            }
+        }
+        case "analyze_image_quality": {
+            const inputPath = String(request.params.arguments?.path);
+            if (!fs.existsSync(inputPath)) {
+                throw new McpError(ErrorCode.InvalidParams, `Path not found: ${inputPath}`);
+            }
+            try {
+                const report = await imageAnalyzer.analyze(inputPath);
+                let output = `## 📷 Image Quality Report\n\n`;
+                output += `- **Total Images**: ${report.total_images}\n`;
+                output += `- **Corrupted**: ${report.corrupted_count}\n`;
+                output += `- **Average Resolution**: ${Math.round(report.average_width)}x${Math.round(report.average_height)}\n`;
+                output += `- **Blurry Images**: ${report.blurry_count}\n\n`;
+                if (report.individual_results.length > 0) {
+                    output += `### 🔬 Sample Detail (Top 5)\n`;
+                    report.individual_results.slice(0, 5).forEach(img => {
+                        const statusEmoji = img.status === "ok" ? (img.is_blurry ? "⚠️" : "✅") : "❌";
+                        output += `${statusEmoji} **${img.filename}**: ${img.width}x${img.height} | Mode: ${img.mode} | Blur: ${img.blur_score?.toFixed(1)}\n`;
+                    });
+                }
+                return {
+                    content: [{ type: "text", text: output }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `ERROR: Image analysis failed: ${error.message}` }],
+                    isError: true
+                };
+            }
+        }
+        case "analyze_media_quality": {
+            const inputPath = String(request.params.arguments?.path);
+            if (!fs.existsSync(inputPath)) {
+                throw new McpError(ErrorCode.InvalidParams, `Path not found: ${inputPath}`);
+            }
+            try {
+                const report = await mediaAnalyzer.analyze(inputPath);
+                let output = `## 🎬 Media Quality Report\n\n`;
+                output += `- **Total Files**: ${report.total_files}\n`;
+                output += `- **OK Files**: ${report.ok_files}\n`;
+                output += `- **Failed Files**: ${report.failed_files}\n`;
+                if ('avg_audio_duration' in report && report.avg_audio_duration) {
+                    output += `- **Average Audio Duration**: ${report.avg_audio_duration.toFixed(2)}s\n`;
+                }
+                if ('avg_video_duration' in report && report.avg_video_duration) {
+                    output += `- **Average Video Duration**: ${report.avg_video_duration.toFixed(2)}s\n`;
+                    output += `- **Average FPS**: ${report.avg_fps?.toFixed(1)}\n`;
+                }
+                output += `\n### 📊 Sample Detail (Top 5)\n`;
+                report.details.slice(0, 5).forEach(item => {
+                    const statusEmoji = item.status === "ok" ? "✅" : "❌";
+                    if (item.type === "audio" && 'sample_rate' in item) {
+                        output += `${statusEmoji} **${item.filename}**: ${item.duration?.toFixed(1)}s | SR: ${item.sample_rate}Hz | Silent: ${item.is_silent}\n`;
+                    }
+                    else if (item.type === "video" && 'width' in item) {
+                        output += `${statusEmoji} **${item.filename}**: ${item.width}x${item.height} | ${item.fps?.toFixed(1)}fps | Risk: ${item.corruption_risk}\n`;
+                    }
+                    else {
+                        output += `${statusEmoji} **${item.filename}**: ${item.error}\n`;
+                    }
+                });
+                return {
+                    content: [{ type: "text", text: output }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `ERROR: Media analysis failed: ${error.message}` }],
+                    isError: true
+                };
+            }
+        }
+        case "generate_quality_report": {
+            const datasetId = String(request.params.arguments?.dataset_id);
+            const datasetPath = String(request.params.arguments?.dataset_path);
+            if (!fs.existsSync(datasetPath)) {
+                throw new McpError(ErrorCode.InvalidParams, `Dataset path not found: ${datasetPath}`);
+            }
+            try {
+                // Optionally load text quality from metadata if available
+                const metadata = await metadataStore.getDataset(datasetId);
+                // TODO: Integrate text quality analysis when available
+                const textQuality = null;
+                const report = await qualityOrchestrator.generateReport(datasetId, datasetPath, textQuality);
+                // Save report to metadata
+                if (metadata) {
+                    metadata.unified_quality_report = report;
+                    await metadataStore.saveDataset(metadata);
+                }
+                let output = `# 📊 Unified Quality Report\n\n`;
+                output += `**Dataset**: ${datasetId}\n`;
+                output += `**Modalities**: ${report.modalities.join(", ")}\n`;
+                output += `**Overall Quality Score**: ${report.overall_quality_score}/100\n\n`;
+                if (report.text_quality) {
+                    output += `## 📝 Text Quality\n`;
+                    output += `- Rows: ${report.text_quality.row_count}\n`;
+                    output += `- Columns: ${report.text_quality.column_count}\n`;
+                    output += `- Missing: ${report.text_quality.missing_percentage.toFixed(1)}%\n`;
+                    output += `- Duplicates: ${report.text_quality.duplicate_percentage.toFixed(1)}%\n\n`;
+                }
+                if (report.image_quality) {
+                    output += `## 🖼️ Image Quality\n`;
+                    output += `- Total Images: ${report.image_quality.total_images}\n`;
+                    output += `- Corrupted: ${report.image_quality.corrupted_count}\n`;
+                    output += `- Avg Resolution: ${report.image_quality.avg_resolution}\n`;
+                    output += `- Blurry: ${report.image_quality.blurry_percentage.toFixed(1)}%\n\n`;
+                }
+                if (report.audio_quality) {
+                    output += `## 🎵 Audio Quality\n`;
+                    output += `- Total Files: ${report.audio_quality.total_files}\n`;
+                    output += `- Avg Duration: ${report.audio_quality.avg_duration.toFixed(1)}s\n`;
+                    output += `- Avg Sample Rate: ${report.audio_quality.avg_sample_rate.toFixed(0)}Hz\n`;
+                    output += `- Silent: ${report.audio_quality.silent_percentage.toFixed(1)}%\n\n`;
+                }
+                if (report.video_quality) {
+                    output += `## 🎬 Video Quality\n`;
+                    output += `- Total Files: ${report.video_quality.total_files}\n`;
+                    output += `- Avg Duration: ${report.video_quality.avg_duration.toFixed(1)}s\n`;
+                    output += `- Avg FPS: ${report.video_quality.avg_fps.toFixed(1)}\n`;
+                    output += `- High Corruption Risk: ${report.video_quality.corruption_risk_high}\n\n`;
+                }
+                output += `## 💡 Recommendations\n`;
+                report.recommendations.forEach(rec => {
+                    output += `- ${rec}\n`;
+                });
+                return {
+                    content: [{ type: "text", text: output }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `ERROR: Quality report generation failed: ${error.message}` }],
+                    isError: true
+                };
+            }
+        }
+        default:
+            throw new McpError(ErrorCode.MethodNotFound, "Tool not found");
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Vesper MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Server error:", error);
+    process.exit(1);
+});