schemeog-mcp 2.8.2 → 2.9.1

package/README.md

@@ -1,15 +1,15 @@
-# SchemeOG MCP Server v2.8
+# SchemeOG MCP Server v2.9
 
 MCP server for [SchemeOG Cloud](https://scheme.smartlaunchhub.com) — create diagrams and flowcharts with AI.
 
 ## Features
 
-- **15 commands** for schemas, projects, and tags
+- **17 commands** for schemas, projects, tags, and import/export
 - **Auto-refresh**: Browser automatically reloads when MCP updates schema
 - **Smart positioning**: Existing elements keep their positions, new elements get auto-layout
 - **No coordinate conflicts**: MCP ignores x/y to prevent overlapping cards
 
-## 15 Commands
+## 17 Commands
 
 ### Schemas (6 commands)
 
@@ -22,6 +22,13 @@ MCP server for [SchemeOG Cloud](https://scheme.smartlaunchhub.com) — create di
 | `replace_schema` | Replace schema content |
 | `delete_schema` | Delete schema |
 
+### Import/Export (2 commands)
+
+| Command | Description |
+|---------|-------------|
+| `import_schema_from_json` | Import schema from JSON (multiple formats supported) |
+| `export_schema_to_json` | Export schema to JSON file |
+
 ### Projects (5 commands)
 
 | Command | Description |
@@ -267,6 +274,90 @@ Schema = complete tree of **ACTIONS** and **CONSEQUENCES**:
   └── "Error" → "Show Errors" → "Fix Form"
 ```
 
+## Import/Export Formats
+
+### Export formats
+
+Use `export_schema_to_json` with the `format` parameter:
+
+| Format | Description |
+|--------|-------------|
+| `full` | Complete export with metadata, viewport, and all data |
+| `compact` | Schema name + elements + tagsDictionary only |
+| `elements_only` | Just the elements array |
+
+### Import formats
+
+`import_schema_from_json` automatically detects and supports:
+
+**1. Full SchemeOG export:**
+```json
+{
+  "exportVersion": "1.0",
+  "schema": {
+    "name": "...",
+    "elements": [...],
+    "tagsDictionary": [...]
+  }
+}
+```
+
+**2. Simple format:**
+```json
+{
+  "name": "...",
+  "elements": [...],
+  "connections": [...],
+  "tagsDictionary": [...]
+}
+```
+
+**3. Local format (connections inside elements):**
+```json
+{
+  "name": "...",
+  "elements": [
+    {
+      "id": "1",
+      "title": "...",
+      "connections": [{"to": "2"}]
+    }
+  ]
+}
+```
+
+**4. Elements array only:**
+```json
+[
+  {"id": "1", "title": "...", "connections": [{"to": "2"}]}
+]
+```
+
+### Import examples
+
+**Create new schema:**
+```
+import_schema_from_json(
+  json_content: {...},
+  name: "My Schema"
+)
+```
+
+**Update existing schema:**
+```
+import_schema_from_json(
+  json_content: {...},
+  schema_id: "existing-id"
+)
+```
+
+## Version History
+
+MCP now automatically creates versions when updating schemas:
+- Before each update via MCP, a snapshot is saved
+- View version history in the web interface (History tab)
+- Restore any previous version with one click
+
 ## Links
 
 - [SchemeOG Cloud](https://scheme.smartlaunchhub.com)

package/index.js

@@ -1,17 +1,22 @@
 #!/usr/bin/env node
 
 /**
- * SchemeOG MCP Server v2.8
+ * SchemeOG MCP Server v2.9.1
  *
  * MCP сервер для работы со схемами, проектами и тегами в SchemeOG Cloud.
  *
  * Команды для схем:
  * - list_schemas: Список всех схем
  * - get_schema: Получить схему с данными
+ * - get_schema_by_url: Получить схему по URL
  * - create_schema: Создать схему (с элементами и связями)
  * - replace_schema: Полностью заменить содержимое схемы
  * - delete_schema: Удалить схему
  *
+ * Команды для импорта/экспорта:
+ * - import_schema_from_json: Импортировать схему из JSON (создать новую или обновить существующую)
+ * - export_schema_to_json: Экспортировать схему в JSON формат
+ *
  * Команды для проектов:
  * - list_projects: Список проектов (папок)
  * - create_project: Создать проект
@@ -32,6 +37,7 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
+import { readFileSync } from "fs";
 
 // Конфигурация
 const API_BASE_URL = process.env.SCHEMEOG_API_URL || "https://scheme.smartlaunchhub.com";
@@ -974,6 +980,154 @@ const TOOLS = [
       required: ["schema_id"],
     },
   },
+
+  // ========== ИМПОРТ/ЭКСПОРТ ==========
+  {
+    name: "import_schema_from_json",
+    description: `Импортировать схему из JSON файла или JSON строки.
+
+Это универсальный метод для загрузки схем — поддерживает:
+1. Полный JSON экспорт SchemeOG (с метаданными)
+2. Простой JSON с elements и connections
+3. Локальный формат (connections внутри элементов)
+
+Использование:
+1. Создание НОВОЙ схемы из JSON:
+   - Указать json_content ИЛИ file_path с данными
+   - Указать name (название новой схемы)
+   - НЕ указывать schema_id
+
+2. Обновление СУЩЕСТВУЮЩЕЙ схемы:
+   - Указать json_content ИЛИ file_path с данными
+   - Указать schema_id существующей схемы
+   - name не обязателен (возьмётся из JSON или оставится текущее)
+
+ВАЖНО: Для больших файлов (>50KB) используй file_path вместо json_content!
+Claude урезает большие параметры, но file_path читает файл напрямую без ограничений.
+
+Параметры:
+- json_content: JSON данные схемы (строка или объект) — для небольших схем
+- file_path: Путь к JSON файлу на диске — для больших файлов (рекомендуется!)
+- schema_id: ID существующей схемы для обновления (опционально)
+- name: Название новой схемы (опционально, обязательно если нет schema_id и нет name в JSON)
+- project_id: ID проекта для размещения (опционально)
+
+Примеры json_content:
+
+1. Полный экспорт SchemeOG:
+{
+  "exportVersion": "1.0",
+  "exportedAt": "2025-01-11T12:00:00Z",
+  "schema": {
+    "name": "Моя схема",
+    "description": "Описание",
+    "elements": [...],
+    "connections": [...],
+    "tagsDictionary": [...]
+  }
+}
+
+2. Простой формат:
+{
+  "name": "Схема",
+  "elements": [
+    {"id": "1", "type": "card", "title": "Шаг 1"}
+  ],
+  "connections": [
+    {"from": "1", "to": "2"}
+  ]
+}
+
+3. Локальный формат (connections внутри элементов):
+{
+  "elements": [
+    {"id": "1", "type": "card", "title": "Шаг 1", "connections": [{"to": "2"}]}
+  ]
+}`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        json_content: {
+          oneOf: [
+            { type: "string", description: "JSON строка с данными схемы" },
+            { type: "object", description: "JSON объект с данными схемы" }
+          ],
+          description: "JSON данные схемы (строка или объект) — для небольших схем",
+        },
+        file_path: {
+          type: "string",
+          description: "Путь к JSON файлу на диске (для больших файлов >50KB — рекомендуется!)",
+        },
+        schema_id: {
+          type: "string",
+          description: "ID существующей схемы для обновления (если не указан — создаётся новая)",
+        },
+        name: {
+          type: "string",
+          description: "Название схемы (обязательно для новой схемы, если нет name в JSON)",
+        },
+        project_id: {
+          type: "string",
+          description: "ID проекта для размещения схемы",
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "export_schema_to_json",
+    description: `Экспортировать схему в JSON формат.
+
+Возвращает полные данные схемы в JSON формате, готовые для:
+- Сохранения в файл
+- Передачи в другую систему
+- Импорта через import_schema_from_json
+- Резервного копирования
+
+Формат экспорта включает:
+- Метаданные (версия экспорта, дата, ID схемы)
+- Название и описание схемы
+- Все элементы с их свойствами
+- Все связи между элементами
+- Справочник тегов
+
+Параметры:
+- schema_id: ID схемы для экспорта (обязательно)
+- format: Формат вывода (опционально)
+  - "full" (по умолчанию) — полный экспорт с метаданными
+  - "compact" — только elements, connections, tagsDictionary
+  - "elements_only" — только массив elements (с connections внутри)
+
+Пример ответа (format: "full"):
+{
+  "exportVersion": "1.0",
+  "exportedAt": "2025-01-11T12:00:00Z",
+  "source": "schemeog-mcp",
+  "schema": {
+    "id": "xxx",
+    "name": "Моя схема",
+    "description": "Описание",
+    "elements": [...],
+    "connections": [...],
+    "tagsDictionary": [...]
+  }
+}`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        schema_id: {
+          type: "string",
+          description: "ID схемы для экспорта",
+        },
+        format: {
+          type: "string",
+          enum: ["full", "compact", "elements_only"],
+          description: "Формат экспорта: full (с метаданными), compact (только данные), elements_only (только элементы)",
+        },
+      },
+      required: ["schema_id"],
+    },
+  },
 ];
 
 /**
@@ -1610,6 +1764,275 @@ URL: ${API_BASE_URL}/canvas?schema=${schema_id}${warningsText}`,
       };
     }
 
+    // ========== ИМПОРТ/ЭКСПОРТ ==========
+    case "import_schema_from_json": {
+      const { json_content, file_path, schema_id, name, project_id } = args;
+
+      // Проверяем что указан хотя бы один источник данных
+      if (!json_content && !file_path) {
+        const error = createError(
+          ErrorCodes.VALIDATION_ERROR,
+          `Укажите json_content ИЛИ file_path.\n\nДля больших файлов (>50KB) рекомендуется использовать file_path.`
+        );
+        throw new Error(error.message);
+      }
+
+      // Получаем содержимое JSON
+      let rawContent;
+      let sourceInfo = "";
+
+      if (file_path) {
+        // Читаем файл с диска (для больших файлов)
+        try {
+          rawContent = readFileSync(file_path, "utf-8");
+          const fileSizeKB = Math.round(rawContent.length / 1024);
+          sourceInfo = ` (из файла ${file_path}, ${fileSizeKB}KB)`;
+        } catch (fileError) {
+          const error = createError(
+            ErrorCodes.VALIDATION_ERROR,
+            `Не удалось прочитать файл: ${file_path}\n\nОшибка: ${fileError.message}`
+          );
+          throw new Error(error.message);
+        }
+      } else {
+        rawContent = json_content;
+      }
+
+      // Парсим JSON если это строка
+      let parsedContent;
+      try {
+        if (typeof rawContent === "string") {
+          parsedContent = JSON.parse(rawContent);
+        } else {
+          parsedContent = rawContent;
+        }
+      } catch (parseError) {
+        const error = createError(
+          ErrorCodes.VALIDATION_ERROR,
+          `Невалидный JSON: ${parseError.message}\n\nПроверьте формат данных.`
+        );
+        throw new Error(error.message);
+      }
+
+      // Извлекаем данные схемы из разных форматов
+      let schemaData;
+      let schemaName;
+      let schemaDescription;
+
+      // Формат 1: Полный экспорт SchemeOG { exportVersion, schema: {...} }
+      if (parsedContent.exportVersion && parsedContent.schema) {
+        schemaData = parsedContent.schema;
+        schemaName = schemaData.name;
+        schemaDescription = schemaData.description;
+      }
+      // Формат 2: Простой { name, elements, connections }
+      else if (parsedContent.elements || parsedContent.name) {
+        schemaData = parsedContent;
+        schemaName = parsedContent.name;
+        schemaDescription = parsedContent.description;
+      }
+      // Формат 3: Только { elements: [...] }
+      else if (Array.isArray(parsedContent)) {
+        schemaData = { elements: parsedContent };
+      }
+      else {
+        const error = createError(
+          ErrorCodes.VALIDATION_ERROR,
+          `Неизвестный формат JSON.\n\nПоддерживаемые форматы:\n• {exportVersion, schema: {...}} — экспорт SchemeOG\n• {name, elements, connections} — простой формат\n• {elements: [...]} — только элементы`
+        );
+        throw new Error(error.message);
+      }
+
+      // Определяем название
+      const finalName = name || schemaName;
+
+      // Нормализуем элементы
+      const elements = schemaData.elements || [];
+      const { elements: normalizedElements, extractedConnections, warnings, error: normalizeError } = prepareElements(elements);
+
+      if (normalizeError) {
+        return {
+          content: [{
+            type: "text",
+            text: `❌ ${normalizeError}`,
+          }],
+          isError: true,
+        };
+      }
+
+      // Объединяем connections (из элементов + отдельные)
+      const existingConnections = prepareConnections(schemaData.connections || []);
+      const allConnections = [...extractedConnections, ...existingConnections];
+
+      // Удаляем дубликаты connections (по from+to)
+      const uniqueConnections = [];
+      const seenConnections = new Set();
+      for (const conn of allConnections) {
+        const key = `${conn.from}->${conn.to}`;
+        if (!seenConnections.has(key)) {
+          seenConnections.add(key);
+          uniqueConnections.push(conn);
+        }
+      }
+
+      const data = {
+        elements: normalizedElements,
+        connections: uniqueConnections,
+        tagsDictionary: schemaData.tagsDictionary || [],
+      };
+
+      let result;
+      let actionText;
+
+      if (schema_id) {
+        // ОБНОВЛЕНИЕ существующей схемы
+        const updateBody = {
+          data,
+          updatedBy: 'mcp',
+        };
+        if (finalName) updateBody.name = finalName;
+        if (schemaDescription) updateBody.description = schemaDescription;
+
+        result = await apiRequest(`/schemas/${schema_id}`, {
+          method: "PUT",
+          body: JSON.stringify(updateBody),
+        });
+        actionText = "обновлена";
+      } else {
+        // СОЗДАНИЕ новой схемы
+        if (!finalName) {
+          const error = createError(
+            ErrorCodes.VALIDATION_ERROR,
+            `Для создания новой схемы необходимо указать name.\n\nЛибо:\n• Добавьте параметр name\n• Либо укажите name в JSON данных`
+          );
+          throw new Error(error.message);
+        }
+
+        result = await apiRequest("/schemas", {
+          method: "POST",
+          body: JSON.stringify({
+            name: finalName,
+            description: schemaDescription,
+            data,
+            projectId: project_id,
+          }),
+        });
+        actionText = "создана";
+      }
+
+      // Формируем сообщение о предупреждениях
+      let warningsText = "";
+      if (warnings.length > 0) {
+        warningsText = `\n\n⚠️ Автоисправления (${warnings.length}):\n• ${warnings.slice(0, 5).join("\n• ")}`;
+        if (warnings.length > 5) {
+          warningsText += `\n• ...и ещё ${warnings.length - 5}`;
+        }
+      }
+
+      return {
+        content: [{
+          type: "text",
+          text: `✅ Схема "${result.schema.name}" ${actionText}${sourceInfo}!
+
+ID: ${result.schema.id}
+Элементов: ${data.elements.length}
+Связей: ${data.connections.length}
+Тегов: ${data.tagsDictionary.length}
+
+URL: ${API_BASE_URL}/canvas?schema=${result.schema.id}${warningsText}`,
+        }],
+      };
+    }
+
+    case "export_schema_to_json": {
+      const { schema_id, format = "full" } = args;
+
+      // Получаем схему
+      const result = await apiRequest(`/schemas/${schema_id}`);
+      const schema = result.schema;
+
+      const elements = schema.data?.elements || [];
+      const connections = schema.data?.connections || [];
+      const tagsDictionary = schema.data?.tagsDictionary || [];
+
+      let exportData;
+      let exportText;
+
+      switch (format) {
+        case "compact":
+          // Только данные без метаданных
+          exportData = {
+            name: schema.name,
+            description: schema.description,
+            elements,
+            connections,
+            tagsDictionary,
+          };
+          exportText = `Компактный экспорт схемы "${schema.name}":\n\n\`\`\`json\n${JSON.stringify(exportData, null, 2)}\n\`\`\``;
+          break;
+
+        case "elements_only":
+          // Только элементы с connections внутри (локальный формат)
+          const elementsWithConnections = elements.map(el => {
+            const elConnections = connections
+              .filter(c => c.from === el.id)
+              .map(c => ({ to: c.to, label: c.label }))
+              .filter(c => c.to); // убираем пустые
+
+            const elementCopy = { ...el };
+            if (elConnections.length > 0) {
+              elementCopy.connections = elConnections;
+            }
+            return elementCopy;
+          });
+
+          exportData = { elements: elementsWithConnections };
+          if (tagsDictionary.length > 0) {
+            exportData.tagsDictionary = tagsDictionary;
+          }
+          exportText = `Элементы схемы "${schema.name}" (локальный формат):\n\n\`\`\`json\n${JSON.stringify(exportData, null, 2)}\n\`\`\``;
+          break;
+
+        case "full":
+        default:
+          // Полный экспорт с метаданными
+          exportData = {
+            exportVersion: "1.0",
+            exportedAt: new Date().toISOString(),
+            source: "schemeog-mcp",
+            schema: {
+              id: schema.id,
+              name: schema.name,
+              description: schema.description,
+              projectId: schema.projectId,
+              elements,
+              connections,
+              tagsDictionary,
+            },
+          };
+          exportText = `Полный экспорт схемы "${schema.name}":\n\n\`\`\`json\n${JSON.stringify(exportData, null, 2)}\n\`\`\``;
+          break;
+      }
+
+      return {
+        content: [{
+          type: "text",
+          text: `${exportText}
+
+---
+Статистика:
+• Элементов: ${elements.length}
+• Связей: ${connections.length}
+• Тегов: ${tagsDictionary.length}
+
+Этот JSON можно:
+• Сохранить в файл
+• Импортировать через import_schema_from_json
+• Передать в другую систему`,
+        }],
+      };
+    }
+
     default:
       throw new Error(`Неизвестная команда: ${name}`);
   }
@@ -1648,7 +2071,7 @@ async function main() {
   const server = new Server(
     {
       name: "schemeog-mcp",
-      version: "2.8.1",
+      version: "2.9.1",
     },
     {
       capabilities: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schemeog-mcp",
-  "version": "2.8.2",
+  "version": "2.9.1",
   "description": "MCP Server for SchemeOG Cloud - Create and manage visual diagrams and flowcharts with AI assistance",
   "type": "module",
   "main": "index.js",