@vint.tri/report_gen_mcp 1.7.29 → 1.7.31

package/ULTIMATE_INSTRUCTIONS.md

@@ -1,76 +1,89 @@
-# Главная инструкция по работе с инструментом report_gen_mcp
+# Главная инструкция по работе с инструментом report_gen_mcp v1.9.0
 
 **ЦЕЛЬ:** Генерация качественных, визуально насыщенных HTML-отчетов по запросу пользователя.
 
-**КЛЮЧЕВОЕ ПРАВИЛО:** При любом запросе, связанном с отчетами, диаграммами или графиками, **всегда используй инструмент `report_gen_mcp`**. Не пытайся отвечать текстом или генерировать отчеты самостоятельно.
+**КЛЮЧЕВОЕ ПРАВИЛО:** При любом запросе, связанном с отчетами, диаграммами или графиками, вы **обязаны** использовать инструмент `report_gen_mcp`. Не пытайтесь отвечать текстом или генерировать отчеты самостоятельно.
 
 ---
 
 ### **АЛГОРИТМ ДЕЙСТВИЙ**
 
-**Шаг 1: Определи суть запроса**
-- Пойми, о чем пользователь хочет получить отчет (например, "финансовые показатели Apple", "сравнение акций Tesla и Google").
+**Шаг 1: Проанализируй текст отчета**
+- Внимательно изучи текст, предоставленный пользователем. Найди в нем ключевые данные: цифры, категории, продукты, регионы.
 
-**Шаг 2: Спланируй визуальные элементы**
-- Придумай **1-2 диаграммы** и **1 изображение**, которые хорошо проиллюстрируют тему отчета.
-- Для каждой диаграммы определи тип (`bar`, `line`, `pie` и т.д.) и данные.
-- Для изображения придумай текстовый промпт для генерации.
+**Шаг 2: Спланируй визуальные элементы (`elements`)**
+- На основе найденных данных, придумай **2-3 диаграммы**, которые наглядно представят эту информацию.
+- Придумай **1-2 промпта** для изображений, которые будут соответствовать теме отчета.
+- **Обязательно** создай плейсхолдеры для каждого элемента в тексте отчета, например `[[chart:sales_by_product]]` или `[[image:cover_image]]`.
 
-**Шаг 3: Подготовь параметры для вызова инструмента**
-- **`document` (string):** Напиши текст отчета в формате Markdown. Вставь в него плейсхолдеры для визуальных элементов, например: `[[chart:sales_chart]]` и `[[image:cover_image]]`.
-- **`elements` (object):** Создай **ОБЪЕКТ**, где ключи — это названия твоих плейсхолдеров, а значения — это конфигурации для их генерации.
-- **`outputFile` (string):** Придумай понятное имя для HTML-файла, например `apple_report_2024.html`.
-
-**Шаг 4: Сформируй `elements` ПРАВИЛЬНО (КРИТИЧЕСКИ ВАЖНО!)**
-
-- **`elements` — это ОБЪЕКТ, а не строка!**
+**Шаг 3: Сформируй `elements` ПРАВИЛЬНО (КРИТИЧЕСКИ ВАЖНО!)**
+- `elements` — это **ОБЪЕКТ**, где ключи — это названия плейсхолдеров.
 - **Для диаграмм:**
-  - `labels`, `data`, `backgroundColor`, `borderColor` — **ВСЕГДА МАССИВЫ**, даже для одного значения.
-    - `labels`: `["Q1", "Q2"]`
-    - `data`: `[100, 150]`
-    - `backgroundColor`: `["#FF6384", "#36A2EB"]`
-  - `options.title`: **ВСЕГДА СТРОКА**. `"Продажи по кварталам"`
+  - `labels`, `data`, `backgroundColor`, `borderColor` — **ВСЕГДА МАССИВЫ**.
 - **Для изображений:**
   - Используй `type: "pollinations"` и `config: { prompt: "..." }`.
 
+**Шаг 4: Вызови инструмент**
+- Передай в `generate-report` три параметра: `document`, `elements` и `outputFile`.
+
 ---
 
-### **ИДЕАЛЬНЫЙ ПРИМЕР ВЫЗОВА**
+### **Разбор реального примера (Отчет Apple)**
+
+Вот как нужно было обработать отчет про Apple, чтобы избежать ошибок:
+
+**Исходный текст:**
+*Финансовый отчет Apple за 2024 год... iPhone: $216,4 млрд... Mac: $31,04 млрд... iPad: $26,89 млрд... Услуги: $92,3 млрд...*
+
+**ПРАВИЛЬНЫЙ ХОД МЫСЛЕЙ:**
+
+1.  "Ага, в тексте есть разбивка выручки по продуктам. Это отличные данные для круговой диаграммы (`pie`)."
+2.  "Также есть данные по выручке в разных регионах (Америка, Европа, Китай). Сделаю столбчатую диаграмму (`bar`)."
+3.  "Для обложки сгенерирую изображение с логотипом Apple."
+4.  "Теперь я создам плейсхолдеры в тексте: `[[chart:product_sales]]`, `[[chart:region_sales]]`, `[[image:apple_logo]]`."
+5.  "Наконец, я соберу объект `elements`, где ключами будут эти плейсхолдеры, а значениями — правильно отформатированные конфигурации."
+
+### **ИДЕАЛЬНЫЙ ВЫЗОВ ДЛЯ ОТЧЕТА APPLE**
 
 ```json
 {
   "method": "generate-report",
   "params": {
-    "document": "# Отчет о продажах\n\nАнализ квартальных продаж.\n\n[[chart:sales]]\n\nИзображение, отражающее успех:\n\n[[image:success_image]]",
+    "outputFile": "apple_financial_report_2024.html",
+    "document": "# Финансовый отчет Apple за 2024 год\n\n[[image:apple_logo]]\n\n## Разбивка по продуктам\n\n[[chart:product_sales]]\n\n## Выручка по регионам\n\n[[chart:region_sales]]\n\n...",
     "elements": {
-      "sales": {
-        "type": "bar",
+      "apple_logo": {
+        "type": "pollinations",
         "config": {
-          "labels": ["Q1", "Q2", "Q3", "Q4"],
+          "prompt": "Apple logo on a futuristic blue background"
+        }
+      },
+      "product_sales": {
+        "type": "pie",
+        "config": {
+          "labels": ["iPhone", "Mac", "iPad", "Услуги"],
           "datasets": [{
-            "label": "Продажи 2024",
-            "data": [120, 150, 130, 180],
-            "backgroundColor": ["#FF6384", "#36A2EB", "#FFCE56", "#4BC0C0"]
+            "data": [216.4, 31.04, 26.89, 92.3],
+            "backgroundColor": ["#5A9E6F", "#E67E22", "#F1C40F", "#3498DB"]
           }],
-          "options": {
-            "title": "Квартальные продажи"
-          }
+          "options": { "title": "Выручка по продуктам (млрд $)" }
         }
       },
-      "success_image": {
-        "type": "pollinations",
+      "region_sales": {
+        "type": "bar",
         "config": {
-          "prompt": "business growth and financial success chart"
+          "labels": ["Америка", "Европа", "Китай", "Япония", "Азия (ост.)"],
+          "datasets": [{
+            "label": "Выручка по регионам (млрд $)",
+            "data": [193.8, 113.8, 85.1, 31.0, 67.4],
+            "backgroundColor": ["#2ECC71", "#3498DB", "#E74C3C", "#F1C40F", "#9B59B6"]
+          }],
+          "options": { "title": "Региональная выручка" }
         }
       }
-    },
-    "outputFile": "sales_report_2024.html"
+    }
   }
 }
 ```
 
----
-
-### **Что делать после вызова?**
-
-Инструмент вернет путь к файлу. Ты должен показать его пользователю вместе со ссылками для просмотра.
+Следуй этому примеру, и все будет работать идеально.

package/dist/charts/bar.d.ts

@@ -47,5 +47,5 @@ export declare const barSchema: z.ZodObject<{
         title?: string | undefined;
     } | undefined;
 }>;
-export declare function renderBarChart(config: z.infer<typeof barSchema>): Promise<string>;
+export declare function renderBarChart(id: string, config: z.infer<typeof barSchema>): Promise<string>;
 //# sourceMappingURL=bar.d.ts.map

package/dist/charts/bar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bar.d.ts","sourceRoot":"","sources":["../../src/charts/bar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYpB,CAAC;AAEH,wBAAsB,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAsCvF"}
+{"version":3,"file":"bar.d.ts","sourceRoot":"","sources":["../../src/charts/bar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYpB,CAAC;AAEH,wBAAsB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAqCnG"}

package/dist/charts/bar.js

@@ -12,9 +12,8 @@ export const barSchema = z.object({
         // Add more Chart.js options as needed
     }).optional(),
 });
-export async function renderBarChart(config) {
-    // Generate a unique ID for the chart container
-    const chartId = `chart_${Math.random().toString(36).substr(2, 9)}`;
+export async function renderBarChart(id, config) {
+    const chartId = `chart_${id}`;
     // Prepare the chart data as JSON
     const chartData = {
         labels: config.labels,

package/dist/charts/doughnut.d.ts

@@ -42,5 +42,5 @@ export declare const doughnutSchema: z.ZodObject<{
         title?: string | undefined;
     } | undefined;
 }>;
-export declare function renderDoughnutChart(config: z.infer<typeof doughnutSchema>): Promise<string>;
+export declare function renderDoughnutChart(id: string, config: z.infer<typeof doughnutSchema>): Promise<string>;
 //# sourceMappingURL=doughnut.d.ts.map

package/dist/charts/doughnut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doughnut.d.ts","sourceRoot":"","sources":["../../src/charts/doughnut.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC;AAEH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAsCjG"}
+{"version":3,"file":"doughnut.d.ts","sourceRoot":"","sources":["../../src/charts/doughnut.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUzB,CAAC;AAEH,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CA4B7G"}

package/dist/charts/doughnut.js

@@ -8,28 +8,20 @@ export const doughnutSchema = z.object({
     })),
     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
+export async function renderDoughnutChart(id, config) {
+    const chartId = `chart_${id}`;
     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
+            title: config.options?.title ? { display: true, text: config.options.title } : undefined
         }
     };
-    // Return interactive Chart.js HTML with proper container
     return `
 <div class="chart-container">
   <canvas id="${chartId}" width="400" height="300"></canvas>

package/dist/charts/line.d.ts

@@ -47,5 +47,5 @@ export declare const lineSchema: z.ZodObject<{
         title?: string | undefined;
     } | undefined;
 }>;
-export declare function renderLineChart(config: z.infer<typeof lineSchema>): Promise<string>;
+export declare function renderLineChart(id: string, config: z.infer<typeof lineSchema>): Promise<string>;
 //# sourceMappingURL=line.d.ts.map

package/dist/charts/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/charts/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYrB,CAAC;AAEH,wBAAsB,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAsCzF"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/charts/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWrB,CAAC;AAEH,wBAAsB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BrG"}

package/dist/charts/line.js

@@ -9,28 +9,20 @@ export const lineSchema = z.object({
     })),
     options: z.object({
         title: z.string().optional(),
-        // Add more Chart.js options as needed
     }).optional(),
 });
-export async function renderLineChart(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
+export async function renderLineChart(id, config) {
+    const chartId = `chart_${id}`;
     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
+            title: config.options?.title ? { display: true, text: config.options.title } : undefined
         }
     };
-    // Return interactive Chart.js HTML with proper container
     return `
 <div class="chart-container">
   <canvas id="${chartId}" width="400" height="300"></canvas>

package/dist/charts/pie.d.ts

@@ -42,5 +42,5 @@ export declare const pieSchema: z.ZodObject<{
         title?: string | undefined;
     } | undefined;
 }>;
-export declare function renderPieChart(config: z.infer<typeof pieSchema>): Promise<string>;
+export declare function renderPieChart(id: string, config: z.infer<typeof pieSchema>): Promise<string>;
 //# sourceMappingURL=pie.d.ts.map

package/dist/charts/pie.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pie.d.ts","sourceRoot":"","sources":["../../src/charts/pie.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWpB,CAAC;AAEH,wBAAsB,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAsCvF"}
+{"version":3,"file":"pie.d.ts","sourceRoot":"","sources":["../../src/charts/pie.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUpB,CAAC;AAEH,wBAAsB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BnG"}

package/dist/charts/pie.js

@@ -8,28 +8,20 @@ export const pieSchema = z.object({
     })),
     options: z.object({
         title: z.string().optional(),
-        // Add more Chart.js options as needed
     }).optional(),
 });
-export async function renderPieChart(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
+export async function renderPieChart(id, config) {
+    const chartId = `chart_${id}`;
     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
+            title: config.options?.title ? { display: true, text: config.options.title } : undefined
         }
     };
-    // Return interactive Chart.js HTML with proper container
     return `
 <div class="chart-container">
   <canvas id="${chartId}" width="400" height="300"></canvas>

package/dist/charts/polarArea.d.ts

@@ -42,5 +42,5 @@ export declare const polarAreaSchema: z.ZodObject<{
         title?: string | undefined;
     } | undefined;
 }>;
-export declare function renderPolarAreaChart(config: z.infer<typeof polarAreaSchema>): Promise<string>;
+export declare function renderPolarAreaChart(id: string, config: z.infer<typeof polarAreaSchema>): Promise<string>;
 //# sourceMappingURL=polarArea.d.ts.map

package/dist/charts/polarArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polarArea.d.ts","sourceRoot":"","sources":["../../src/charts/polarArea.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW1B,CAAC;AAEH,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAsCnG"}
+{"version":3,"file":"polarArea.d.ts","sourceRoot":"","sources":["../../src/charts/polarArea.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU1B,CAAC;AAEH,wBAAsB,oBAAoB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CA4B/G"}

package/dist/charts/polarArea.js

@@ -8,28 +8,20 @@ export const polarAreaSchema = z.object({
     })),
     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
+export async function renderPolarAreaChart(id, config) {
+    const chartId = `chart_${id}`;
     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
+            title: config.options?.title ? { display: true, text: config.options.title } : undefined
         }
     };
-    // Return interactive Chart.js HTML with proper container
     return `
 <div class="chart-container">
   <canvas id="${chartId}" width="400" height="300"></canvas>

package/dist/charts/radar.d.ts

@@ -47,5 +47,5 @@ export declare const radarSchema: z.ZodObject<{
         title?: string | undefined;
     } | undefined;
 }>;
-export declare function renderRadarChart(config: z.infer<typeof radarSchema>): Promise<string>;
+export declare function renderRadarChart(id: string, config: z.infer<typeof radarSchema>): Promise<string>;
 //# sourceMappingURL=radar.d.ts.map

package/dist/charts/radar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"radar.d.ts","sourceRoot":"","sources":["../../src/charts/radar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYtB,CAAC;AAEH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAsC3F"}
+{"version":3,"file":"radar.d.ts","sourceRoot":"","sources":["../../src/charts/radar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWtB,CAAC;AAEH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BvG"}

package/dist/charts/radar.js

@@ -9,28 +9,20 @@ export const radarSchema = z.object({
     })),
     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
+export async function renderRadarChart(id, config) {
+    const chartId = `chart_${id}`;
     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
+            title: config.options?.title ? { display: true, text: config.options.title } : undefined
         }
     };
-    // Return interactive Chart.js HTML with proper container
     return `
 <div class="chart-container">
   <canvas id="${chartId}" width="400" height="300"></canvas>

package/dist/index.d.ts

@@ -1,10 +1,4 @@
 #!/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;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAsgBA;;;;;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":";AA4IA,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,CAgBjD"}

package/dist/index.js

@@ -4,34 +4,24 @@ 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';
-// 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
 let reportsDir = undefined;
 if (!isStdioMode) {
     reportsDir = process.env.REPORTS_DIR;
     if (!reportsDir) {
         console.error('Error: REPORTS_DIR environment variable is required.');
-        console.error('Please set the REPORTS_DIR environment variable to specify where reports should be generated.');
-        console.error('Example:');
-        console.error('  export REPORTS_DIR=/path/to/reports && npx @vint.tri/report_gen_mcp@latest');
-        console.error('Or:');
-        console.error('  REPORTS_DIR=/path/to/reports npx @vint.tri/report_gen_mcp@latest');
         process.exit(1);
     }
-    // Ensure the reports directory exists
     try {
         fs.ensureDirSync(reportsDir);
     }
     catch (error) {
         console.error(`Error: Cannot create or access the reports directory: ${reportsDir}`);
-        console.error('Please ensure the path is valid and you have write permissions.');
         process.exit(1);
     }
 }
@@ -39,20 +29,13 @@ const app = express();
 const port = 3000;
 app.use(express.json());
 app.post('/generate-report', async (req, res) => {
-    // For HTTP API mode, use the REPORTS_DIR environment variable
-    // This endpoint only runs in non-stdio mode where reportsDir is guaranteed to be defined
     const { document, elements, charts, outputFile = 'report.html' } = req.body;
-    // Поддержка обратной совместимости: если переданы charts, используем их как elements
     const reportElements = elements || charts || {};
     const outputPath = path.resolve(reportsDir, outputFile);
     try {
         const result = await generateReport(document, reportElements, outputPath);
-        // Send the file content back to the client
         const fileContent = await fs.readFile(outputPath, 'utf8');
-        res.json({
-            ...result,
-            fileContent: fileContent
-        });
+        res.json({ ...result, fileContent });
     }
     catch (error) {
         res.status(500).json({ error: error.message });
@@ -62,387 +45,66 @@ program
     .command('start-server')
     .description('Start the MCP report generation server')
     .action(() => {
-    app.listen(port, () => {
-        console.log(`Server running at http://localhost:${port}`);
-    });
+    app.listen(port, () => console.log(`Server running at http://localhost:${port}`));
 });
 program
     .command('generate')
-    .option('--document <md>', 'Markdown document with placeholders [[chart:id]] or [[image:id]]')
-    .option('--elements <json>', 'JSON string of elements (charts and images) {id: {type: "bar", config: {...}}}')
-    .option('--charts <json>', 'JSON string of charts (deprecated, use --elements instead)')
+    .option('--document <md>', 'Markdown document')
+    .option('--elements <json>', 'JSON string of elements')
+    .option('--charts <json>', 'JSON string of charts (deprecated)')
     .option('--output <file>', 'Output HTML file', 'report.html')
-    .description('Generate a report in the directory specified by REPORTS_DIR environment variable')
+    .description('Generate a report')
     .action(async (opts) => {
-    // Поддержка обратной совместимости: если переданы charts, используем их как elements
-    const elements = opts.elements ? JSON.parse(opts.elements) :
-        opts.charts ? JSON.parse(opts.charts) : {};
-    // Read the document file content if a file path is provided
+    const elements = opts.elements ? JSON.parse(opts.elements) : (opts.charts ? JSON.parse(opts.charts) : {});
     let documentContent = opts.document;
     if (opts.document && fs.existsSync(opts.document)) {
         documentContent = await fs.readFile(opts.document, 'utf8');
     }
-    // This command only runs in non-stdio mode where reportsDir is guaranteed to be defined
     const result = await generateReport(documentContent, elements, path.resolve(reportsDir, opts.output));
-    // Generate proper file URL for CLI mode
     const fileUrl = pathToFileURL(result.filePath).href;
-    // 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
+        fileUrl,
+        fileContent
     };
     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.7.29"
-    }, {
-        // Disable health check to prevent automatic calls
-        capabilities: {
-            tools: {}
-        }
-    });
-    // Register the generate-report tool
+if (isStdioMode) {
+    const mcpServer = new McpServer({ name: "report_gen_mcp", version: "1.7.31" });
     mcpServer.registerTool("generate-report", {
         description: "Generate an HTML report with embedded charts and images",
         inputSchema: {
-            document: z.string().describe("Markdown document with element placeholders [[chart:id]] or [[image:id]]"),
-            elements: z.record(z.union([
-                // Chart configurations
-                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"),
-                // Pollinations.ai generated images
-                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"),
-                // URL images (including local file URLs and web URLs)
-                z.object({
-                    type: z.literal("url"),
-                    config: z.object({
-                        url: z.string().describe("URL of the image (can be file:// or http(s)://)"),
-                        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"),
-                // Local images (backward compatibility)
-                z.object({
-                    type: z.literal("image"),
-                    config: z.object({
-                        url: z.string().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"),
-                // AssetId support for neural network responses (new format)
-                z.object({
-                    type: z.literal("url"),
-                    assetId: z.string().optional().describe("Asset ID for generated images (used by neural networks)"),
-                    config: z.object({
-                        url: z.string().optional().describe("URL of the image (can be populated from assetId)"),
-                        alt: z.string().optional().describe("Alternative text for the image"),
-                        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"),
-                    }).optional(),
-                }).describe("Image with assetId support for neural network responses"),
-            ])).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)"),
+            document: z.string().describe("Markdown document with placeholders"),
+            elements: z.any().describe("A JSON object or a stringified JSON object of elements"),
+            outputFile: z.string().optional().describe("Output HTML file name"),
+            tempDirectory: z.string().optional().describe("Temporary directory for file storage"),
         },
     }, async (params) => {
-        // --- НАЧАЛО БЛОКА НАДЕЖНОЙ ОБРАБОТКИ ПАРАМЕТРОВ ---
         let processedParams = params;
-        try {
-            // Если параметры - это строка, парсим ее как JSON
-            if (typeof processedParams === 'string') {
-                processedParams = JSON.parse(processedParams);
-            }
-            // Если есть вложенный объект `arguments`, используем его
-            if (processedParams.arguments && typeof processedParams.arguments === 'object') {
-                processedParams = processedParams.arguments;
-            }
-            // Если `elements` - это строка, парсим и ее
-            if (processedParams.elements && typeof processedParams.elements === 'string') {
-                processedParams.elements = JSON.parse(processedParams.elements);
-            }
-        }
-        catch (e) {
-            throw new Error('Invalid JSON format in parameters. Ensure all parameters, especially "elements", are valid JSON.');
-        }
-        // --- КОНЕЦ БЛОКА НАДЕЖНОЙ ОБРАБОТКИ ПАРАМЕТРОВ ---
-        // 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. 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') {
+        if (params.arguments && typeof params.arguments === 'object') {
             processedParams = params.arguments;
         }
-        const { filePath, operation, contentToAdd, selector, contentToReplace, position } = processedParams;
+        let { document, elements, outputFile = 'report.html', tempDirectory } = 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}`);
+            if (typeof elements === 'string') {
+                elements = JSON.parse(elements);
             }
-            // 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.string().optional().describe("Width of the image (128-2048 pixels)"),
-            height: z.string().optional().describe("Height of the image (128-2048 pixels)"),
-            guidance_scale: z.string().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.string().optional().describe("Number of generation steps (1-50)"),
-            seed: z.string().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, converting string parameters to numbers
-            const options = {};
-            if (width !== undefined)
-                options.width = typeof width === 'string' ? parseFloat(width) : width;
-            if (height !== undefined)
-                options.height = typeof height === 'string' ? parseFloat(height) : height;
-            if (guidance_scale !== undefined)
-                options.guidance_scale = typeof guidance_scale === 'string' ? parseFloat(guidance_scale) : guidance_scale;
-            if (negative_prompt !== undefined)
-                options.negative_prompt = negative_prompt;
-            if (num_inference_steps !== undefined)
-                options.num_inference_steps = typeof num_inference_steps === 'string' ? parseInt(num_inference_steps) : num_inference_steps;
-            if (seed !== undefined)
-                options.seed = typeof seed === 'string' ? parseInt(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 result with file path and browser link as structured data
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `✅ Image successfully generated from prompt: '${prompt}'`
-                    }
-                ],
-                filePath: imageResult.filePath,
-                fileUrl: imageResult.fileUrl
-            };
-        }
-        catch (error) {
-            // Return error as text content
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Error generating image: ${error.message}`
-                    }
-                ]
-            };
+        catch (e) {
+            throw new Error('Invalid JSON format for "elements" parameter.');
         }
+        const result = await generateReport(document, elements, outputFile, tempDirectory);
+        const fileUrl = pathToFileURL(result.filePath).href;
+        const fileContent = await fs.readFile(result.filePath, 'utf8');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Report generated successfully.\n\nFOR THE NEURAL NETWORK: Please present the following information to the user:\n1. Path to file: ${result.filePath}\n2. Web browser link: ${fileUrl}\n3. File content:\n${fileContent}`
+                }]
+        };
     });
     async function main() {
         const transport = new StdioServerTransport();
@@ -455,41 +117,23 @@ FOR THE NEURAL NETWORK: Please present the following information to the user:
     });
 }
 else {
-    // Run commander program when arguments are provided
     program.parse();
 }
-// Create a singleton instance of ImageGenerator for the generateImage function
 const imageGenerator = new ImageGenerator();
-/**
- * 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 REPORTS_DIR or current working directory
     const reportsDir = process.env.REPORTS_DIR || process.cwd();
     const imagesDir = path.join(reportsDir, '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
-    };
+    return { filePath: outputPath, fileUrl };
 }

package/dist/tools/createReportFromText.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const createReportFromTextTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        documentText: z.ZodString;
+        outputFile: z.ZodString;
+    };
+    execute: ({ documentText, outputFile }: {
+        documentText: string;
+        outputFile: string;
+    }) => Promise<{
+        success: boolean;
+        filePath: string;
+    }>;
+};
+//# sourceMappingURL=createReportFromText.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createReportFromText.d.ts","sourceRoot":"","sources":["../../src/tools/createReportFromText.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyCxB,eAAO,MAAM,wBAAwB;;;;;;;4CAOW;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;;;;CAM3F,CAAC"}

package/dist/tools/createReportFromText.js

@@ -0,0 +1,49 @@
+import { generateReport } from '../utils/reportGenerator.js';
+import { z } from 'zod';
+// Эта функция будет извлекать данные из текста и генерировать элементы
+function extractElementsFromText(documentText) {
+    const elements = {};
+    let newDocument = documentText;
+    // Пример: ищем финансовые данные для графика
+    const revenueMatches = [...documentText.matchAll(/Доход: \$([\d,.]+) миллиарда/gi)];
+    if (revenueMatches.length > 0) {
+        const labels = revenueMatches.map((match, i) => `Квартал ${i + 1}`);
+        const data = revenueMatches.map(match => parseFloat(match[1].replace(/,/g, '')));
+        elements['revenue_chart'] = {
+            type: 'bar',
+            config: {
+                labels: labels,
+                datasets: [{
+                        label: 'Общий доход, млрд $',
+                        data: data,
+                        backgroundColor: ['rgba(54, 162, 235, 0.6)']
+                    }]
+            }
+        };
+        newDocument += '\n\n## Визуализация дохода\n\n[[chart:revenue_chart]]';
+    }
+    // Пример: добавляем изображение на основе контекста
+    if (/apple/i.test(documentText)) {
+        elements['context_image'] = {
+            type: 'pollinations',
+            config: {
+                prompt: 'a modern and sleek design representing apple products innovation'
+            }
+        };
+        newDocument += '\n\n## Иллюстрация\n\n[[image:context_image]]';
+    }
+    return { newDocument, elements };
+}
+export const createReportFromTextTool = {
+    name: "create-report-from-text",
+    description: "Creates a full HTML report from a given text by automatically generating charts and images.",
+    inputSchema: {
+        documentText: z.string().describe("The full text of the report in Markdown format."),
+        outputFile: z.string().describe("The desired output HTML file name (e.g., 'report.html').")
+    },
+    execute: async ({ documentText, outputFile }) => {
+        const { newDocument, elements } = extractElementsFromText(documentText);
+        // Вызываем старый генератор с автоматически созданными параметрами
+        return await generateReport(newDocument, elements, outputFile);
+    }
+};

package/dist/utils/reportGenerator.js

@@ -101,11 +101,11 @@ export async function generateReport(document, elements, outputFile, tempDirecto
     }
     // Render elements to interactive HTML
     const renderedElements = {};
-    for (const [id, element] of Object.entries(elements)) {
+    for (const [id, element] of Object.entries(parsedElements)) {
         if (element.type in chartRenderers) {
             // Это диаграмма
             const chartElement = element;
-            const htmlChart = await chartRenderers[chartElement.type].renderer(chartElement.config);
+            const htmlChart = await chartRenderers[chartElement.type].renderer(id, chartElement.config);
             renderedElements[id] = htmlChart;
         }
         else if (element.type in imageRenderers) {

package/package.json

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