@vint.tri/report_gen_mcp 1.5.17 → 1.5.18

package/dist/index.d.ts

@@ -1,19 +1,3 @@
 #!/usr/bin/env node
-/**
- * Generate an image from a text prompt using AI
- * @param prompt Text prompt for image generation (must be in English)
- * @param options Additional options for image generation
- * @returns Promise<{ filePath: string, fileUrl: string }> Object containing file path and URL of the saved image
- */
-export declare function generateImage(prompt: string, options?: {
-    width?: number;
-    height?: number;
-    guidance_scale?: number;
-    negative_prompt?: string;
-    num_inference_steps?: number;
-    seed?: number;
-}): Promise<{
-    filePath: string;
-    fileUrl: string;
-}>;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AA+fA;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAgCjD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -4,12 +4,10 @@ import { program } from 'commander';
 import { generateReport } from './utils/reportGenerator.js';
 import path from 'path';
 import fs from 'fs-extra';
-import os from 'os';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
 import { pathToFileURL } from 'url';
-import { ImageGenerator } from './mcp/imageGenerationServer.js';
+import { simpleReportTool } from './tools/simpleReport.js';
 // Check if we're running in stdio mode (no command-line arguments)
 const isStdioMode = process.argv.length === 2;
 // For CLI and HTTP API modes, check for mandatory REPORTS_DIR environment variable
@@ -103,339 +101,17 @@ if (process.argv.length === 2) {
     // No command specified, run in stdio mode using MCP SDK
     const mcpServer = new McpServer({
         name: "report_gen_mcp",
-        version: "1.5.17"
+        version: "1.5.18"
     }, {
         // Disable health check to prevent automatic calls
         capabilities: {
             tools: {}
         }
     });
-    // Register the generate-report tool
-    mcpServer.registerTool("generate-report", {
-        description: "Generate an HTML report with embedded charts",
-        inputSchema: {
-            document: z.string().describe("Markdown document with element placeholders [[chart:id]] or [[image:id]]"),
-            elements: z.record(z.union([
-                z.object({
-                    type: z.enum(["bar", "line", "pie", "doughnut", "radar", "polarArea"]),
-                    config: z.object({
-                        labels: z.array(z.string()),
-                        datasets: z.array(z.object({
-                            label: z.string().optional(),
-                            data: z.array(z.number()),
-                            backgroundColor: z.array(z.string()).optional(),
-                            borderColor: z.array(z.string()).optional(),
-                            fill: z.boolean().optional(),
-                        })),
-                        options: z.object({
-                            title: z.string().optional(),
-                        }).optional(),
-                    }),
-                }).describe("Chart configuration"),
-                z.object({
-                    type: z.literal("pollinations"),
-                    config: z.object({
-                        prompt: z.string().describe("Text description of the image to generate"),
-                        width: z.number().optional().default(512).describe("Width of the image in pixels"),
-                        height: z.number().optional().default(512).describe("Height of the image in pixels"),
-                        model: z.string().optional().default("flux").describe("Model to use for image generation"),
-                        seed: z.number().optional().describe("Seed for reproducible image generation"),
-                        nologo: z.boolean().optional().default(true).describe("Remove logo from the image"),
-                        enhance: z.boolean().optional().default(true).describe("Enhance image quality"),
-                    }),
-                }).describe("Pollinations.ai generated image configuration"),
-                z.object({
-                    type: z.literal("url"),
-                    config: z.object({
-                        url: z.string().url().describe("URL of the image"),
-                        alt: z.string().optional().describe("Alternative text for the image"),
-                        width: z.number().optional().describe("Width of the image in pixels"),
-                        height: z.number().optional().describe("Height of the image in pixels"),
-                    }),
-                }).describe("Image from URL configuration"),
-                z.object({
-                    type: z.literal("image"),
-                    config: z.object({
-                        url: z.string().url().describe("File URL of the image"),
-                        alt: z.string().optional().describe("Alternative text for the image"),
-                        width: z.number().optional().describe("Width of the image in pixels"),
-                        height: z.number().optional().describe("Height of the image in pixels"),
-                    }),
-                }).describe("Local image file configuration"),
-            ])).describe("Report elements (charts and images) mapped by ID"),
-            outputFile: z.string().optional().describe("Output HTML file path"),
-            tempDirectory: z.string().optional().describe("Temporary directory for file storage (optional, will use REPORTS_DIR environment variable if set)"),
-        },
-    }, async (params) => {
-        // Handle case where arguments might be sent as a JSON string by Claude desktop
-        let processedParams = params;
-        if (typeof params === 'string') {
-            try {
-                processedParams = JSON.parse(params);
-            }
-            catch (parseError) {
-                throw new Error('Invalid JSON string in arguments');
-            }
-        }
-        if (processedParams.arguments && typeof processedParams.arguments === 'string') {
-            try {
-                processedParams = JSON.parse(processedParams.arguments);
-            }
-            catch (parseError) {
-                throw new Error('Invalid JSON string in arguments');
-            }
-        }
-        else if (processedParams.arguments && typeof processedParams.arguments === 'object') {
-            processedParams = processedParams.arguments;
-        }
-        // Extract parameters correctly, ensuring outputFile is not nested within elements
-        const { document, elements, charts, outputFile = 'report.html', tempDirectory } = processedParams;
-        // Поддержка обратной совместимости: если переданы charts, используем их как elements
-        const reportElements = elements || charts || {};
-        // Determine the output directory:
-        // 1. Use REPORTS_DIR environment variable if set
-        // 2. Fall back to tempDirectory parameter if provided
-        // 3. Default to system temp directory if neither is available
-        let outputDir;
-        if (process.env.REPORTS_DIR) {
-            outputDir = process.env.REPORTS_DIR;
-            // Ensure the reports directory exists
-            try {
-                fs.ensureDirSync(outputDir);
-            }
-            catch (error) {
-                throw new Error(`Cannot create or access the reports directory: ${outputDir}`);
-            }
-        }
-        else if (tempDirectory) {
-            outputDir = tempDirectory;
-        }
-        else {
-            outputDir = os.tmpdir();
-        }
-        const outputPath = path.resolve(outputDir, outputFile);
-        try {
-            const result = await generateReport(document, reportElements, outputPath);
-            // Generate proper file URL
-            const fileUrl = pathToFileURL(outputPath).href;
-            // Read the file content
-            const fileContent = await fs.readFile(outputPath, 'utf8');
-            // Create a comprehensive result object
-            const comprehensiveResult = {
-                success: true,
-                message: "Report generated successfully",
-                filePath: outputPath,
-                fileUrl: fileUrl,
-                fileContent: fileContent
-            };
-            // Return comprehensive information for neural network to use
-            // Neural network should present to user: file path, web link, and file content
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Report generated successfully.
-
-FOR THE NEURAL NETWORK: Please present the following information to the user:
-1. Path to file: ${outputPath}
-2. Web browser link: ${fileUrl}
-3. Web link 2: http://localhost:3000/${outputFile}
-4. File content:
-${fileContent}`
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            throw error;
-        }
-    });
-    // Register a new tool for editing existing reports
-    mcpServer.registerTool("edit-report", {
-        description: "Edit an existing HTML report by adding or removing content",
-        inputSchema: {
-            filePath: z.string().describe("Path to the existing HTML report file"),
-            operation: z.enum(["add", "remove", "replace"]).describe("Operation to perform: add content, remove content, or replace content"),
-            contentToAdd: z.string().optional().describe("Content to add to the report (for 'add' operation)"),
-            selector: z.string().optional().describe("CSS selector for element to modify (for 'add', 'remove', or 'replace' operations)"),
-            contentToReplace: z.string().optional().describe("Content to replace the selected element with (for 'replace' operation)"),
-            position: z.enum(["beforebegin", "afterbegin", "beforeend", "afterend"]).optional().describe("Position to insert new content relative to the selected element (for 'add' operation)"),
-        },
-    }, async (params) => {
-        // Handle case where arguments might be sent as a JSON string
-        let processedParams = params;
-        if (typeof params === 'string') {
-            try {
-                processedParams = JSON.parse(params);
-            }
-            catch (parseError) {
-                throw new Error('Invalid JSON string in arguments');
-            }
-        }
-        else if (params.arguments && typeof params.arguments === 'object') {
-            processedParams = params.arguments;
-        }
-        const { filePath, operation, contentToAdd, selector, contentToReplace, position } = processedParams;
-        try {
-            // Check if file exists
-            if (!await fs.pathExists(filePath)) {
-                throw new Error(`File not found: ${filePath}`);
-            }
-            // Read the existing file content
-            let fileContent = await fs.readFile(filePath, 'utf8');
-            // Perform the requested operation
-            switch (operation) {
-                case "add":
-                    if (!contentToAdd || !selector || !position) {
-                        throw new Error("contentToAdd, selector, and position are required for 'add' operation");
-                    }
-                    // Insert content at the specified position relative to the selected element
-                    const addRegex = new RegExp(`(<${selector}[^>]*>)|(<\\/[^>]*${selector}>)`, 'i');
-                    const addMatch = fileContent.match(addRegex);
-                    if (addMatch) {
-                        const matchIndex = addMatch.index;
-                        const matchLength = addMatch[0].length;
-                        switch (position) {
-                            case "beforebegin":
-                                fileContent = fileContent.slice(0, matchIndex) + contentToAdd + fileContent.slice(matchIndex);
-                                break;
-                            case "afterbegin":
-                                fileContent = fileContent.slice(0, matchIndex + matchLength) + contentToAdd + fileContent.slice(matchIndex + matchLength);
-                                break;
-                            case "beforeend":
-                                const closingTagIndex = fileContent.indexOf('</', matchIndex);
-                                fileContent = fileContent.slice(0, closingTagIndex) + contentToAdd + fileContent.slice(closingTagIndex);
-                                break;
-                            case "afterend":
-                                const endTagIndex = fileContent.indexOf('>', matchIndex) + 1;
-                                fileContent = fileContent.slice(0, endTagIndex) + contentToAdd + fileContent.slice(endTagIndex);
-                                break;
-                        }
-                    }
-                    else {
-                        throw new Error(`Element with selector '${selector}' not found`);
-                    }
-                    break;
-                case "remove":
-                    if (!selector) {
-                        throw new Error("selector is required for 'remove' operation");
-                    }
-                    // Remove the element with the specified selector
-                    const removeRegex = new RegExp(`<${selector}[^>]*>[^]*?<\\/[^>]*${selector}[^>]*>|<${selector}[^>]*/?>`, 'gi');
-                    fileContent = fileContent.replace(removeRegex, '');
-                    break;
-                case "replace":
-                    if (!selector || !contentToReplace) {
-                        throw new Error("selector and contentToReplace are required for 'replace' operation");
-                    }
-                    // Replace the element with the specified selector
-                    const replaceRegex = new RegExp(`<${selector}[^>]*>[^]*?<\\/[^>]*${selector}[^>]*>|<${selector}[^>]*/?>`, 'gi');
-                    fileContent = fileContent.replace(replaceRegex, contentToReplace);
-                    break;
-                default:
-                    throw new Error(`Unsupported operation: ${operation}`);
-            }
-            // Write the modified content back to the file
-            await fs.writeFile(filePath, fileContent, 'utf8');
-            // Generate proper file URL
-            const fileUrl = pathToFileURL(filePath).href;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Report edited successfully.
-
-FOR THE NEURAL NETWORK: Please present the following information to the user:
-1. Path to file: ${filePath}
-2. Web browser link: ${fileUrl}
-3. Operation performed: ${operation}`
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            throw new Error(`Error editing report: ${error.message}`);
-        }
-    });
-    // Register the generate-image tool
-    mcpServer.registerTool("generate-image", {
-        description: "Generate an image from a text prompt using AI",
-        inputSchema: {
-            prompt: z.string().describe("Text prompt for image generation (must be in English)"),
-            width: z.number().optional().describe("Width of the image (128-2048 pixels)"),
-            height: z.number().optional().describe("Height of the image (128-2048 pixels)"),
-            guidance_scale: z.number().optional().describe("Strength of prompt following (1.0-20.0)"),
-            negative_prompt: z.string().optional().describe("Negative prompt (what NOT to include in the image)"),
-            num_inference_steps: z.number().optional().describe("Number of generation steps (1-50)"),
-            seed: z.number().optional().describe("Seed for reproducibility (0 = random)")
-        },
-    }, async (params) => {
-        try {
-            // Handle case where arguments might be sent as a JSON string
-            let processedParams = params;
-            if (typeof params === 'string') {
-                try {
-                    processedParams = JSON.parse(params);
-                }
-                catch (parseError) {
-                    throw new Error('Invalid JSON string in arguments');
-                }
-            }
-            else if (params.arguments && typeof params.arguments === 'object') {
-                processedParams = params.arguments;
-            }
-            const { prompt, width, height, guidance_scale, negative_prompt, num_inference_steps, seed } = processedParams;
-            if (!prompt) {
-                throw new Error("Parameter 'prompt' is required");
-            }
-            // Prepare options for generateImage function. Parameters are already numbers due to schema validation.
-            const options = {};
-            if (width !== undefined)
-                options.width = width;
-            if (height !== undefined)
-                options.height = height;
-            if (guidance_scale !== undefined)
-                options.guidance_scale = guidance_scale;
-            if (negative_prompt !== undefined)
-                options.negative_prompt = negative_prompt;
-            if (num_inference_steps !== undefined)
-                options.num_inference_steps = num_inference_steps;
-            if (seed !== undefined)
-                options.seed = seed;
-            // Generate the image
-            const imageResult = await generateImage(prompt, options);
-            // Extract base64 data from the saved file
-            const imageData = await fs.readFile(imageResult.filePath);
-            const base64Data = imageData.toString('base64');
-            // Return file paths and URLs
-            const reportServerPort = 2000;
-            const httpUrl = `http://localhost:${reportServerPort}/${path.basename(imageResult.filePath)}`;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Image generated successfully.
-
-FOR THE NEURAL NETWORK: Please present the following information to the user:
-1. Path to file: ${imageResult.filePath}
-2. Web browser link: ${imageResult.fileUrl}
-3. Web link: ${httpUrl}`
-                    }
-                ]
-            };
-        }
-        catch (error) {
-            // Return error as text content
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Error generating image: ${error.message}`
-                    }
-                ]
-            };
-        }
-    });
+    mcpServer.registerTool(simpleReportTool.name, {
+        description: simpleReportTool.description,
+        inputSchema: simpleReportTool.inputSchema,
+    }, simpleReportTool.action);
     async function main() {
         const transport = new StdioServerTransport();
         await mcpServer.connect(transport);
@@ -450,47 +126,3 @@ else {
     // Run commander program when arguments are provided
     program.parse();
 }
-// Create a singleton instance of ImageGenerator for the generateImage function
-const imageGenerator = new ImageGenerator();
-// Start the report server in non-stdio mode as well
-if (!isStdioMode && reportsDir) {
-    const reportServer = express();
-    const reportServerPort = 2000;
-    reportServer.use(express.static(reportsDir));
-    reportServer.listen(reportServerPort, () => {
-        console.log(`Report server running at http://localhost:${reportServerPort}`);
-    });
-}
-/**
- * Generate an image from a text prompt using AI
- * @param prompt Text prompt for image generation (must be in English)
- * @param options Additional options for image generation
- * @returns Promise<{ filePath: string, fileUrl: string }> Object containing file path and URL of the saved image
- */
-export async function generateImage(prompt, options) {
-    // Generate the image data URI
-    const imageDataUri = await imageGenerator.generateImage(prompt, options);
-    // Extract base64 data without prefix
-    let base64Data = imageDataUri;
-    if (imageDataUri.startsWith("data:image/jpeg;base64,")) {
-        base64Data = imageDataUri.substring("data:image/jpeg;base64,".length);
-    }
-    // Save image to home folder
-    const homeDir = os.homedir();
-    const imagesDir = path.join(homeDir, 'generated_images');
-    await fs.ensureDir(imagesDir);
-    // Create unique filename
-    const timestamp = Date.now();
-    const filename = `generated-image-${timestamp}.jpeg`;
-    const outputPath = path.join(imagesDir, filename);
-    // Save image to file
-    const imageBuffer = Buffer.from(base64Data, 'base64');
-    await fs.writeFile(outputPath, imageBuffer);
-    // Create file URL
-    const fileUrl = pathToFileURL(outputPath).href;
-    // Return both file path and URL
-    return {
-        filePath: outputPath,
-        fileUrl: fileUrl
-    };
-}

package/dist/tools/simpleReport.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const simpleReportTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        document: z.ZodString;
+        outputFile: z.ZodOptional<z.ZodString>;
+    };
+    action: (params: any) => Promise<{
+        content: {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+            };
+        }[];
+    }>;
+};
+//# sourceMappingURL=simpleReport.d.ts.map

package/dist/tools/simpleReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleReport.d.ts","sourceRoot":"","sources":["../../src/tools/simpleReport.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,gBAAgB;;;;;;;qBAOJ,GAAG;iBAwCG;YAAE,IAAI,EAAE,UAAU,CAAC;YAAC,QAAQ,EAAE;gBAAE,GAAG,EAAE,MAAM,CAAC;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,EAAE;;CAa7F,CAAC"}

package/dist/tools/simpleReport.js

@@ -0,0 +1,62 @@
+import { generateReport } from '../utils/reportGenerator.js';
+import { z } from 'zod';
+import { pathToFileURL } from 'url';
+import fs from 'fs-extra';
+export const simpleReportTool = {
+    name: "generate-report",
+    description: "Generate an HTML report from a single string of Markdown content with embedded image and chart tags.",
+    inputSchema: {
+        document: z.string().describe("The full content of the report in Markdown format, with `<img>` and `<canvas>` tags for images and charts."),
+        outputFile: z.string().optional().describe("The name of the output HTML file."),
+    },
+    action: async (params) => {
+        let { document, outputFile } = params;
+        const elements = {};
+        // Regex to find canvas tags and extract id and data-chart
+        const canvasRegex = /<canvas\s+id="([^"]+)"\s+data-chart='([^']*)'><\/canvas>/g;
+        document = document.replace(canvasRegex, (match, id, chartConfigString) => {
+            try {
+                const chartConfig = JSON.parse(chartConfigString);
+                elements[id] = chartConfig;
+                return `[[chart:${id}]]`;
+            }
+            catch (error) {
+                console.error(`Error parsing chart config for id ${id}:`, error);
+                // Keep the original tag if parsing fails to avoid losing content
+                return match;
+            }
+        });
+        // Regex to find img tags and extract id and data-image
+        const imgRegex = /<img\s+id="([^"]+)"\s+data-image='([^']*)'\/?>/g;
+        document = document.replace(imgRegex, (match, id, imageConfigString) => {
+            try {
+                const imageConfig = JSON.parse(imageConfigString);
+                elements[id] = imageConfig;
+                return `[[image:${id}]]`;
+            }
+            catch (error) {
+                console.error(`Error parsing image config for id ${id}:`, error);
+                // Keep the original tag if parsing fails
+                return match;
+            }
+        });
+        if (!outputFile) {
+            outputFile = `report-${Date.now()}.html`;
+        }
+        const result = await generateReport(document, elements, outputFile);
+        const fileUrl = pathToFileURL(result.filePath).href;
+        const fileContent = await fs.readFile(result.filePath, 'utf8');
+        const response = {
+            content: [
+                {
+                    type: 'resource',
+                    resource: {
+                        uri: fileUrl,
+                        text: fileContent,
+                    },
+                },
+            ],
+        };
+        return response;
+    },
+};

package/dist/tools/testReport.d.ts

@@ -0,0 +1,12 @@
+export declare const testReportTool: {
+    name: string;
+    description: string;
+    inputSchema: {};
+    action: () => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+};
+//# sourceMappingURL=testReport.d.ts.map

package/dist/tools/testReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testReport.d.ts","sourceRoot":"","sources":["../../src/tools/testReport.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc;;;;;;;;;;CAyE1B,CAAC"}

package/dist/tools/testReport.js

@@ -0,0 +1,76 @@
+import { generateReport } from '../utils/reportGenerator.js';
+import { pathToFileURL } from 'url';
+import fs from 'fs-extra';
+export const testReportTool = {
+    name: "test-report",
+    description: "Generate a hardcoded test report to verify that the MCP server is working correctly.",
+    inputSchema: {},
+    action: async () => {
+        const reportContent = `# Test Report
+
+This is a test report.
+
+## Image
+
+<img src="https://www.google.com/images/branding/googlelogo/2x/googlelogo_color_272x92dp.png" alt="Google Logo" />
+
+## Chart
+
+<canvas id="myChart"></canvas>
+<script>
+  const ctx = document.getElementById('myChart').getContext('2d');
+  new Chart(ctx, {
+    type: 'bar',
+    data: {
+      labels: ['Red', 'Blue', 'Yellow', 'Green', 'Purple', 'Orange'],
+      datasets: [{
+        label: '# of Votes',
+        data: [12, 19, 3, 5, 2, 3],
+        backgroundColor: [
+          'rgba(255, 99, 132, 0.2)',
+          'rgba(54, 162, 235, 0.2)',
+          'rgba(255, 206, 86, 0.2)',
+          'rgba(75, 192, 192, 0.2)',
+          'rgba(153, 102, 255, 0.2)',
+          'rgba(255, 159, 64, 0.2)'
+        ],
+        borderColor: [
+          'rgba(255, 99, 132, 1)',
+          'rgba(54, 162, 235, 1)',
+          'rgba(255, 206, 86, 1)',
+          'rgba(75, 192, 192, 1)',
+          'rgba(153, 102, 255, 1)',
+          'rgba(255, 159, 64, 1)'
+        ],
+        borderWidth: 1
+      }]
+    },
+    options: {
+      scales: {
+        y: {
+          beginAtZero: true
+        }
+      }
+    }
+  });
+</script>
+`;
+        const result = await generateReport(reportContent, {}, "test-report.html");
+        const fileUrl = pathToFileURL(result.filePath).href;
+        const fileContent = await fs.readFile(result.filePath, 'utf8');
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Test report generated successfully.
+
+FOR THE NEURAL NETWORK: Please present the following information to the user:
+1. Path to file: ${result.filePath}
+2. Web browser link: ${fileUrl}
+3. File content:
+${fileContent}`
+                }
+            ]
+        };
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vint.tri/report_gen_mcp",
-  "version": "1.5.17",
+  "version": "1.5.18",
   "description": "CLI tool for generating HTML reports with embedded charts and images",
   "main": "dist/index.js",
   "bin": {