@vint.tri/report_gen_mcp 1.1.0 → 1.1.1

package/FIX_SUMMARY.md

@@ -0,0 +1,103 @@
+# Report Generation Issue Fix Summary
+
+## Problem
+The report generation was failing with the following error:
+```
+Error calling tool generate-report: Error: Error invoking remote method 'mcp:call-tool': McpError: MCP error -32602: MCP error -32602: Invalid arguments for tool generate-report: [
+  {
+    "code": "invalid_type",
+    "expected": "array",
+    "received": "string",
+    "path": [
+      "charts",
+      "dollar_rate_chart",
+      "config",
+      "datasets",
+      0,
+      "backgroundColor"
+    ],
+    "message": "Expected array, received string"
+  },
+  {
+    "code": "invalid_type",
+    "expected": "array",
+    "received": "string",
+    "path": [
+      "charts",
+      "dollar_rate_chart",
+      "config",
+      "datasets",
+      0,
+      "borderColor"
+    ],
+    "message": "Expected array, received string"
+  }
+]
+```
+
+## Root Cause
+The issue was in the chart configuration where `backgroundColor` and `borderColor` properties were provided as strings instead of arrays of strings. According to the schema validation in `src/charts/line.ts`, these properties are expected to be arrays:
+
+```typescript
+export const lineSchema = z.object({
+  labels: z.array(z.string()),
+  datasets: z.array(z.object({
+    label: z.string(),
+    data: z.array(z.number()),
+    borderColor: z.array(z.string()).optional(),
+    fill: z.boolean().optional(),
+  })),
+  options: z.object({
+    title: z.string().optional(),
+  }).optional(),
+});
+```
+
+## Solution
+I fixed the configuration by:
+1. Removing the `backgroundColor` property entirely since it's not defined in the schema
+2. Changing `borderColor` from a string `"rgba(54, 162, 235, 1)"` to an array `["rgba(54, 162, 235, 1)"]`
+
+## Fixed Configuration
+The corrected chart configuration is:
+
+```json
+{
+  "dollar_rate_chart": {
+    "type": "line",
+    "config": {
+      "labels": [
+        "16.08.2025",
+        "19.08.2025",
+        "20.08.2025",
+        "21.08.2025",
+        "22.08.2025",
+        "23.08.2025"
+      ],
+      "datasets": [
+        {
+          "label": "Курс USD/RUB",
+          "data": [
+            80.0224,
+            80.4256,
+            80.3466,
+            80.1045,
+            80.2548,
+            80.7498
+          ],
+          "borderColor": [
+            "rgba(54, 162, 235, 1)"
+          ],
+          "fill": false
+        }
+      ],
+      "options": {
+        "title": "Динамика курса доллара США к рублю"
+      }
+    }
+  }
+}
+```
+
+## Verification
+The report was successfully generated using the fixed configuration and can be found at `test_reports/dollar_rate_report.html`.

package/README.md

@@ -1,11 +1,11 @@
-# Report Generator MCP Tool
+# Report Generator MCP Tool v1.1.1
 
-A powerful CLI tool for generating HTML reports with embedded charts, designed to work seamlessly with Claude Desktop as an MCP (Model Context Protocol) extension.
+A powerful CLI tool for generating HTML reports with embedded interactive charts, designed to work seamlessly with Claude Desktop as an MCP (Model Context Protocol) extension.
 
 ## Features
 
 - Generate professional HTML reports from Markdown documents
-- Embed customizable charts (bar, line, pie) directly in reports
+- Embed customizable interactive charts (bar, line, pie, doughnut, radar, polarArea) directly in reports
 - Dual operation modes:
   - Command-line interface for direct usage
   - Stdio mode for Claude Desktop integration
@@ -131,7 +131,7 @@ Different regions show varying performance levels.
 
 The `charts` parameter is an object where each key is a chart ID that matches a placeholder in your document, and each value is a chart configuration object with:
 
-- `type`: The chart type ("bar", "line", or "pie")
+- `type`: The chart type ("bar", "line", "pie", "doughnut", "radar", or "polarArea")
 - `config`: The Chart.js configuration for that chart
 
 #### Required Chart Data Structure
@@ -389,7 +389,7 @@ npm test
 **Parameters:**
 - `document` (string): Markdown document with chart placeholders `[[chart:id]]`
 - `charts` (object): Chart configurations mapped by ID
-  - `type` (string): Chart type ("bar", "line", or "pie")
+  - `type` (string): Chart type ("bar", "line", "pie", "doughnut", "radar", or "polarArea")
   - `config` (object): Chart.js configuration object
 - `outputFile` (string, optional): Output HTML file path (defaults to "report.html")
 - `tempDirectory` (string, **required for Claude Desktop**): Temporary directory for file storage. This parameter is required when using the tool with Claude Desktop to prevent read-only file system errors.

package/dist/charts/bar.js

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { ChartJSNodeCanvas } from 'chartjs-node-canvas';
 export const barSchema = z.object({
     labels: z.array(z.string()),
     datasets: z.array(z.object({
@@ -14,26 +13,38 @@ export const barSchema = z.object({
     }).optional(),
 });
 export async function renderBarChart(config) {
-    const chartConfig = {
-        type: 'bar',
-        data: {
-            labels: config.labels,
-            datasets: config.datasets,
-        },
-        options: {
-            ...config.options,
-            plugins: {
-                title: config.options?.title ? {
-                    display: true,
-                    text: config.options.title
-                } : undefined
-            }
-        },
+    // Generate a unique ID for the chart container
+    const chartId = `chart_${Math.random().toString(36).substr(2, 9)}`;
+    // Prepare the chart data as JSON
+    const chartData = {
+        labels: config.labels,
+        datasets: config.datasets,
+    };
+    // Prepare the chart options
+    const chartOptions = {
+        ...config.options,
+        plugins: {
+            title: config.options?.title ? {
+                display: true,
+                text: config.options.title
+            } : undefined
+        }
     };
-    const width = 800;
-    const height = 600;
-    const chartJSNodeCanvas = new ChartJSNodeCanvas({ width, height });
-    const buffer = await chartJSNodeCanvas.renderToBuffer(chartConfig);
-    const base64Image = buffer.toString('base64');
-    return `<img src="data:image/png;base64,${base64Image}" alt="Chart" />`;
+    // Return interactive Chart.js HTML
+    return `
+<div>
+  <canvas id="${chartId}" width="800" height="600"></canvas>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function() {
+      const ctx = document.getElementById('${chartId}').getContext('2d');
+      new Chart(ctx, {
+        type: 'bar',
+        data: ${JSON.stringify(chartData)},
+        options: ${JSON.stringify(chartOptions)}
+      });
+    });
+  </script>
+</div>
+  `.trim();
 }

package/dist/charts/doughnut.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+export const doughnutSchema = z.object({
+    labels: z.array(z.string()),
+    datasets: z.array(z.object({
+        data: z.array(z.number()),
+        backgroundColor: z.array(z.string()).optional(),
+        borderColor: z.array(z.string()).optional(),
+    })),
+    options: z.object({
+        title: z.string().optional(),
+        // Add more Chart.js options as needed
+    }).optional(),
+});
+export async function renderDoughnutChart(config) {
+    // Generate a unique ID for the chart container
+    const chartId = `chart_${Math.random().toString(36).substr(2, 9)}`;
+    // Prepare the chart data as JSON
+    const chartData = {
+        labels: config.labels,
+        datasets: config.datasets,
+    };
+    // Prepare the chart options
+    const chartOptions = {
+        ...config.options,
+        plugins: {
+            title: config.options?.title ? {
+                display: true,
+                text: config.options.title
+            } : undefined
+        }
+    };
+    // Return interactive Chart.js HTML
+    return `
+<div>
+  <canvas id="${chartId}" width="800" height="600"></canvas>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function() {
+      const ctx = document.getElementById('${chartId}').getContext('2d');
+      new Chart(ctx, {
+        type: 'doughnut',
+        data: ${JSON.stringify(chartData)},
+        options: ${JSON.stringify(chartOptions)}
+      });
+    });
+  </script>
+</div>
+  `.trim();
+}

package/dist/charts/line.js

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { ChartJSNodeCanvas } from 'chartjs-node-canvas';
 export const lineSchema = z.object({
     labels: z.array(z.string()),
     datasets: z.array(z.object({
@@ -14,26 +13,38 @@ export const lineSchema = z.object({
     }).optional(),
 });
 export async function renderLineChart(config) {
-    const chartConfig = {
-        type: 'line',
-        data: {
-            labels: config.labels,
-            datasets: config.datasets,
-        },
-        options: {
-            ...config.options,
-            plugins: {
-                title: config.options?.title ? {
-                    display: true,
-                    text: config.options.title
-                } : undefined
-            }
-        },
+    // Generate a unique ID for the chart container
+    const chartId = `chart_${Math.random().toString(36).substr(2, 9)}`;
+    // Prepare the chart data as JSON
+    const chartData = {
+        labels: config.labels,
+        datasets: config.datasets,
+    };
+    // Prepare the chart options
+    const chartOptions = {
+        ...config.options,
+        plugins: {
+            title: config.options?.title ? {
+                display: true,
+                text: config.options.title
+            } : undefined
+        }
     };
-    const width = 800;
-    const height = 600;
-    const chartJSNodeCanvas = new ChartJSNodeCanvas({ width, height });
-    const buffer = await chartJSNodeCanvas.renderToBuffer(chartConfig);
-    const base64Image = buffer.toString('base64');
-    return `<img src="data:image/png;base64,${base64Image}" alt="Chart" />`;
+    // Return interactive Chart.js HTML
+    return `
+<div>
+  <canvas id="${chartId}" width="800" height="600"></canvas>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function() {
+      const ctx = document.getElementById('${chartId}').getContext('2d');
+      new Chart(ctx, {
+        type: 'line',
+        data: ${JSON.stringify(chartData)},
+        options: ${JSON.stringify(chartOptions)}
+      });
+    });
+  </script>
+</div>
+  `.trim();
 }

package/dist/charts/pie.js

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { ChartJSNodeCanvas } from 'chartjs-node-canvas';
 export const pieSchema = z.object({
     labels: z.array(z.string()),
     datasets: z.array(z.object({
@@ -13,26 +12,38 @@ export const pieSchema = z.object({
     }).optional(),
 });
 export async function renderPieChart(config) {
-    const chartConfig = {
-        type: 'pie',
-        data: {
-            labels: config.labels,
-            datasets: config.datasets,
-        },
-        options: {
-            ...config.options,
-            plugins: {
-                title: config.options?.title ? {
-                    display: true,
-                    text: config.options.title
-                } : undefined
-            }
-        },
+    // Generate a unique ID for the chart container
+    const chartId = `chart_${Math.random().toString(36).substr(2, 9)}`;
+    // Prepare the chart data as JSON
+    const chartData = {
+        labels: config.labels,
+        datasets: config.datasets,
+    };
+    // Prepare the chart options
+    const chartOptions = {
+        ...config.options,
+        plugins: {
+            title: config.options?.title ? {
+                display: true,
+                text: config.options.title
+            } : undefined
+        }
     };
-    const width = 800;
-    const height = 600;
-    const chartJSNodeCanvas = new ChartJSNodeCanvas({ width, height });
-    const buffer = await chartJSNodeCanvas.renderToBuffer(chartConfig);
-    const base64Image = buffer.toString('base64');
-    return `<img src="data:image/png;base64,${base64Image}" alt="Chart" />`;
+    // Return interactive Chart.js HTML
+    return `
+<div>
+  <canvas id="${chartId}" width="800" height="600"></canvas>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function() {
+      const ctx = document.getElementById('${chartId}').getContext('2d');
+      new Chart(ctx, {
+        type: 'pie',
+        data: ${JSON.stringify(chartData)},
+        options: ${JSON.stringify(chartOptions)}
+      });
+    });
+  </script>
+</div>
+  `.trim();
 }

package/dist/charts/polarArea.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+export const polarAreaSchema = z.object({
+    labels: z.array(z.string()),
+    datasets: z.array(z.object({
+        data: z.array(z.number()),
+        backgroundColor: z.array(z.string()).optional(),
+        borderColor: z.array(z.string()).optional(),
+    })),
+    options: z.object({
+        title: z.string().optional(),
+        // Add more Chart.js options as needed
+    }).optional(),
+});
+export async function renderPolarAreaChart(config) {
+    // Generate a unique ID for the chart container
+    const chartId = `chart_${Math.random().toString(36).substr(2, 9)}`;
+    // Prepare the chart data as JSON
+    const chartData = {
+        labels: config.labels,
+        datasets: config.datasets,
+    };
+    // Prepare the chart options
+    const chartOptions = {
+        ...config.options,
+        plugins: {
+            title: config.options?.title ? {
+                display: true,
+                text: config.options.title
+            } : undefined
+        }
+    };
+    // Return interactive Chart.js HTML
+    return `
+<div>
+  <canvas id="${chartId}" width="800" height="600"></canvas>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function() {
+      const ctx = document.getElementById('${chartId}').getContext('2d');
+      new Chart(ctx, {
+        type: 'polarArea',
+        data: ${JSON.stringify(chartData)},
+        options: ${JSON.stringify(chartOptions)}
+      });
+    });
+  </script>
+</div>
+  `.trim();
+}

package/dist/charts/radar.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export const radarSchema = z.object({
+    labels: z.array(z.string()),
+    datasets: z.array(z.object({
+        label: z.string(),
+        data: z.array(z.number()),
+        backgroundColor: z.array(z.string()).optional(),
+        borderColor: z.array(z.string()).optional(),
+    })),
+    options: z.object({
+        title: z.string().optional(),
+        // Add more Chart.js options as needed
+    }).optional(),
+});
+export async function renderRadarChart(config) {
+    // Generate a unique ID for the chart container
+    const chartId = `chart_${Math.random().toString(36).substr(2, 9)}`;
+    // Prepare the chart data as JSON
+    const chartData = {
+        labels: config.labels,
+        datasets: config.datasets,
+    };
+    // Prepare the chart options
+    const chartOptions = {
+        ...config.options,
+        plugins: {
+            title: config.options?.title ? {
+                display: true,
+                text: config.options.title
+            } : undefined
+        }
+    };
+    // Return interactive Chart.js HTML
+    return `
+<div>
+  <canvas id="${chartId}" width="800" height="600"></canvas>
+  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function() {
+      const ctx = document.getElementById('${chartId}').getContext('2d');
+      new Chart(ctx, {
+        type: 'radar',
+        data: ${JSON.stringify(chartData)},
+        options: ${JSON.stringify(chartOptions)}
+      });
+    });
+  </script>
+</div>
+  `.trim();
+}

package/dist/index.js

@@ -80,18 +80,24 @@ program
     const result = await generateReport(documentContent, charts, path.resolve(reportsDir, opts.output));
     // Generate proper file URL for CLI mode
     const fileUrl = pathToFileURL(result.filePath).href;
-    const resultWithUrl = {
-        ...result,
-        fileUrl: fileUrl
+    // Read the file content
+    const fileContent = await fs.readFile(result.filePath, 'utf8');
+    // Create a comprehensive result object
+    const comprehensiveResult = {
+        success: true,
+        message: "Report generated successfully",
+        filePath: result.filePath,
+        fileUrl: fileUrl,
+        fileContent: fileContent
     };
-    console.log(JSON.stringify(resultWithUrl));
+    console.log(JSON.stringify(comprehensiveResult, null, 2));
 });
 // Handle stdio mode for Claude Desktop integration
 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.0.31",
+        version: "1.1.1",
     }, {
         // Disable health check to prevent automatic calls
         capabilities: {
@@ -104,7 +110,7 @@ if (process.argv.length === 2) {
         inputSchema: {
             document: z.string().describe("Markdown document with chart placeholders [[chart:id]]"),
             charts: z.record(z.object({
-                type: z.enum(["bar", "line", "pie"]),
+                type: z.enum(["bar", "line", "pie", "doughnut", "radar", "polarArea"]),
                 config: z.object({
                     labels: z.array(z.string()),
                     datasets: z.array(z.object({
@@ -163,16 +169,21 @@ if (process.argv.length === 2) {
             const result = await generateReport(document, charts, 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 {
                 content: [
                     {
                         type: "text",
-                        text: JSON.stringify({
-                            ...result,
-                            message: "Report generated successfully",
-                            filePath: outputPath,
-                            fileUrl: fileUrl
-                        })
+                        text: JSON.stringify(comprehensiveResult, null, 2)
                     }
                 ]
             };

package/dist/utils/reportGenerator.js

@@ -4,12 +4,16 @@ import { marked } from 'marked';
 import { barSchema, renderBarChart } from '../charts/bar.js';
 import { lineSchema, renderLineChart } from '../charts/line.js';
 import { pieSchema, renderPieChart } from '../charts/pie.js';
-// Add more imports for other chart types as needed
+import { doughnutSchema, renderDoughnutChart } from '../charts/doughnut.js';
+import { radarSchema, renderRadarChart } from '../charts/radar.js';
+import { polarAreaSchema, renderPolarAreaChart } from '../charts/polarArea.js';
 const chartRenderers = {
     bar: { schema: barSchema, renderer: renderBarChart },
     line: { schema: lineSchema, renderer: renderLineChart },
     pie: { schema: pieSchema, renderer: renderPieChart },
-    // Add more chart types here
+    doughnut: { schema: doughnutSchema, renderer: renderDoughnutChart },
+    radar: { schema: radarSchema, renderer: renderRadarChart },
+    polarArea: { schema: polarAreaSchema, renderer: renderPolarAreaChart },
 };
 export async function generateReport(document, charts, outputFile) {
     // Validate charts
@@ -19,27 +23,31 @@ export async function generateReport(document, charts, outputFile) {
             throw new Error(`Unsupported chart type: ${type}`);
         schema.parse(config);
     }
-    // Render charts to HTML img tags
+    // Render charts to interactive HTML
     const renderedCharts = {};
     for (const [id, { type, config }] of Object.entries(charts)) {
-        const htmlImg = await chartRenderers[type].renderer(config);
-        renderedCharts[id] = htmlImg;
+        const htmlChart = await chartRenderers[type].renderer(config);
+        renderedCharts[id] = htmlChart;
     }
     // Replace placeholders in Markdown, e.g., [[chart:id]]
     let mdWithCharts = document;
-    for (const [id, htmlImg] of Object.entries(renderedCharts)) {
-        mdWithCharts = mdWithCharts.replace(new RegExp(`\\[\\[chart:${id}\\]\\]`, 'g'), htmlImg);
+    for (const [id, htmlChart] of Object.entries(renderedCharts)) {
+        mdWithCharts = mdWithCharts.replace(new RegExp(`\\[\\[chart:${id}\\]\\]`, 'g'), htmlChart);
     }
     // Convert Markdown to HTML
     const htmlContent = await marked(mdWithCharts);
-    // Wrap in full HTML template
+    // Wrap in full HTML template with Chart.js library
     const template = `
   <!DOCTYPE html>
   <html lang="en">
   <head>
     <meta charset="UTF-8">
     <title>Report</title>
-    <style> body { font-family: Arial, sans-serif; } img { max-width: 100%; } </style>
+    <style>
+      body { font-family: Arial, sans-serif; }
+      .chart-container { margin: 20px 0; }
+    </style>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
   </head>
   <body>
     <%- htmlContent %>

package/dollar_rate_charts.json

@@ -0,0 +1,35 @@
+{
+  "dollar_rate_chart": {
+    "type": "line",
+    "config": {
+      "labels": [
+        "16.08.2025",
+        "19.08.2025",
+        "20.08.2025",
+        "21.08.2025",
+        "22.08.2025",
+        "23.08.2025"
+      ],
+      "datasets": [
+        {
+          "label": "Курс USD/RUB",
+          "data": [
+            80.0224,
+            80.4256,
+            80.3466,
+            80.1045,
+            80.2548,
+            80.7498
+          ],
+          "borderColor": [
+            "rgba(54, 162, 235, 1)"
+          ],
+          "fill": false
+        }
+      ],
+      "options": {
+        "title": "Динамика курса доллара США к рублю"
+      }
+    }
+  }
+}

package/dollar_rate_report.md

@@ -0,0 +1,7 @@
+# Отчет о курсе доллара за неделю (16.08.2025 - 23.08.2025)
+
+Этот отчет показывает динамику курса доллара США к российскому рублю за последнюю неделю.
+
+[[chart:dollar_rate_chart]]
+
+Данные взяты с официального источника Банка России.

package/dollar_rate_report_fixed.json

@@ -0,0 +1,39 @@
+{
+  "document": "# Отчет о курсе доллара за неделю (16.08.2025 - 23.08.2025)\n\nЭтот отчет показывает динамику курса доллара США к российскому рублю за последнюю неделю.\n\n[[chart:dollar_rate_chart]]\n\nДанные взяты с официального источника Банка России.",
+  "charts": {
+    "dollar_rate_chart": {
+      "type": "line",
+      "config": {
+        "labels": [
+          "16.08.2025",
+          "19.08.2025",
+          "20.08.2025",
+          "21.08.2025",
+          "22.08.2025",
+          "23.08.2025"
+        ],
+        "datasets": [
+          {
+            "label": "Курс USD/RUB",
+            "data": [
+              80.0224,
+              80.4256,
+              80.3466,
+              80.1045,
+              80.2548,
+              80.7498
+            ],
+            "borderColor": [
+              "rgba(54, 162, 235, 1)"
+            ],
+            "fill": false
+          }
+        ],
+        "options": {
+          "title": "Динамика курса доллара США к рублю"
+        }
+      }
+    }
+  },
+  "outputFile": "dollar_rate_report.html"
+}

package/generate_report.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Set the reports directory
+export REPORTS_DIR="./test_reports"
+
+# Create the reports directory if it doesn't exist
+mkdir -p "$REPORTS_DIR"
+
+# Generate the report using the CLI
+node dist/index.js generate \
+  --document dollar_rate_report.md \
+  --charts "$(cat dollar_rate_charts.json)" \
+  --output dollar_rate_report.html
+
+echo "Report generated in $REPORTS_DIR/dollar_rate_report.html"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vint.tri/report_gen_mcp",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "CLI tool for generating HTML reports with embedded charts",
   "main": "dist/index.js",
   "bin": {
@@ -13,21 +13,20 @@
     "test": "echo \"No tests yet\""
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "chart.js": "^3.9.1",
-    "chartjs-node-canvas": "^4.1.6",
+    "@modelcontextprotocol/sdk": "^1.0.3",
+    "chart.js": "^4.4.4",
     "commander": "^12.1.0",
     "ejs": "^3.1.10",
     "express": "^4.19.2",
     "fs-extra": "^11.2.0",
-    "marked": "^13.0.2",
+    "marked": "^14.1.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.5",
     "@types/express": "^4.17.21",
     "@types/fs-extra": "^11.0.4",
-    "@types/node": "^22.4.1",
+    "@types/node": "^22.5.0",
     "typescript": "^5.5.4"
   },
   "license": "MIT",

package/test_fixed_report.js

@@ -0,0 +1,56 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+
+// Read the fixed configuration
+const config = JSON.parse(fs.readFileSync('./dollar_rate_report_fixed.json', 'utf8'));
+
+// Set the reports directory
+process.env.REPORTS_DIR = './test_reports';
+
+// Spawn the report generator in stdio mode
+const child = spawn('node', ['dist/index.js']);
+
+// Listen for data from the child process
+child.stdout.on('data', (data) => {
+  console.log(`stdout: ${data}`);
+});
+
+child.stderr.on('data', (data) => {
+  console.error(`stderr: ${data}`);
+});
+
+child.on('close', (code) => {
+  console.log(`child process exited with code ${code}`);
+});
+
+// Send the MCP initialize message
+const initializeMessage = {
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: "2024-08-07",
+    capabilities: {},
+    clientInfo: {
+      name: "test-client",
+      version: "1.0.0"
+    }
+  }
+};
+
+child.stdin.write(JSON.stringify(initializeMessage) + '\n');
+
+// Send the tool call message
+const toolCallMessage = {
+  jsonrpc: "2.0",
+  id: 2,
+  method: "tools/call",
+  params: {
+    name: "generate-report",
+    arguments: config
+  }
+};
+
+setTimeout(() => {
+  child.stdin.write(JSON.stringify(toolCallMessage) + '\n');
+}, 1000);