aact 2.1.5 → 3.0.0-beta.2

package/README.md

@@ -19,7 +19,7 @@ CLI и библиотека для валидации, анализа и ген
 
 <img src="https://github.com/Byndyusoft/aact/assets/1096954/a3c3b3b0-a09b-4da7-aca4-5538159b371c" width="15"/> Телеграм-канал: [Архитектура распределённых систем](https://t.me/rsa_enc)
 
-aact можно использовать двумя способами: как **CLI** (`npx aact check`, авто-фикс, генерация артефактов) или как **библиотеку** (импортировать `checkAcl`, `analyzeArchitecture` и пр. в свои тесты на vitest/jest). CLI — ниже, library-режим — в [соответствующем разделе](#использование-как-библиотеки).
+aact можно использовать двумя способами: как **CLI** (`npx aact check`, авто-фикс, генерация артефактов) или как **библиотеку** (импортировать `aclRule`, `analyzeArchitecture` и пр. в свои тесты на vitest/jest). CLI — ниже, library-режим — в [соответствующем разделе](#использование-как-библиотеки).
 
 ## Quick Start (CLI)
 
@@ -93,26 +93,37 @@ export default config;
 
 ```ts
 import {
-  loadPlantumlElements,
-  mapContainersFromPlantumlElements,
-  checkAcl,
-  checkAcyclic,
-  checkCrud,
+  plantumlFormat,
+  aclRule,
+  acyclicRule,
+  crudRule,
   analyzeArchitecture,
+  validateModel,
 } from "aact";
 
-const elements = await loadPlantumlElements("architecture.puml");
-const model = mapContainersFromPlantumlElements(elements);
+// Загрузка через format — возвращает Model + diagnostic issues
+const { model, issues } = await plantumlFormat.load("architecture.puml");
+for (const issue of issues) console.warn(`model:`, issue);
 
-// Проверка правил
-const aclViolations = checkAcl(model.allContainers);
-const cyclicViolations = checkAcyclic(model.allContainers);
+// Проверка правил — uniform signature (model, options?) => Violation[]
+const aclViolations = aclRule.check(model);
+const cyclicViolations = acyclicRule.check(model);
+const crudViolations = crudRule.check(model, { repoTags: ["repo", "dao"] });
 
 // Анализ метрик
 const { report } = analyzeArchitecture(model);
 console.log(`Elements: ${report.elementsCount}`);
+
+// Прямой доступ к containers / boundaries — Record<name, ...>
+for (const container of Object.values(model.containers)) {
+  console.log(`${container.kind} ${container.name}`);
+}
+const ordersService = model.containers["orders"];
 ```
 
+Полный API: [`Model`](./src/model/types.ts), [`Format`](./src/formats/types.ts),
+[`RuleDefinition`](./src/rules/types.ts). См. `CHANGELOG.md` для v2 → v3 migration.
+
 ## Примеры
 
 Запускаемые из коробки (склонируй репо, `cd examples/<name>`, `npx aact check`):
@@ -122,7 +133,7 @@ console.log(`Elements: ${report.elementsCount}`);
 
 Тестовые сценарии (для разработчиков пакета, запускаются через `vitest`):
 
-- [`examples/banking-plantuml/`](examples/banking-plantuml/) и [`examples/microservices-structurizr/`](examples/microservices-structurizr/) — интеграционные тесты архитектуры из `resources/`.
+- [`examples/banking-plantuml/`](examples/banking-plantuml/) и [`examples/microservices-structurizr/`](examples/microservices-structurizr/) — интеграционные тесты архитектуры из `fixtures/`.
 
 ## Документация
 
@@ -130,6 +141,27 @@ console.log(`Elements: ${report.elementsCount}`);
 - [ADR](ADRs/) — Architecture Decision Records
 - [Roadmap](roadmap.md) — планы развития
 
+## Testing
+
+Тестовый стек разделён на четыре уровня:
+
+```bash
+pnpm test            # все unit + integration + e2e
+pnpm test:unit       # только unit
+pnpm test:integration # интеграционные на реальных фикстурах
+pnpm test:e2e        # subprocess-тесты CLI через execa
+pnpm test:coverage   # с v8 coverage + порогами
+pnpm test:mutation   # Stryker mutation testing
+```
+
+**Метрики качества тестов:**
+
+- **Coverage** (v8): порог в CI — statements ≥95%, branches ≥85%, functions ≥95%, lines ≥95%
+- **Mutation score** (Stryker) ≥95% — каждое смысловое изменение в исходнике должно ломать хотя бы один тест
+- **Property-based** (`@fast-check/vitest`) на option-bearing правилах — защита от «hardcoded literal where option should be read» бага
+- **Inline snapshots** на генераторах для regression-pin'а формата вывода
+- **E2E** на цепочке `init → check → fix → recheck` через `npx aact` в subprocess
+
 ## Публичные материалы
 
 ### Раз архитектура — «as Code», почему бы её не покрыть тестами?!
@@ -172,13 +204,13 @@ https://www.youtube.com/watch?v=fb2UjqjHGUE
 
 ## Пример архитектуры, которую покроем тестами
 
-[![C4](resources/architecture/Demo%20Tests.svg)](resources/architecture/Demo%20Tests.svg)
+[![C4](fixtures/architecture/Demo%20Tests.svg)](fixtures/architecture/Demo%20Tests.svg)
 
 ## Пример тестов
 
-1. [find diff in configs and uml containers](examples/banking-plantuml/architecture.test.ts) — проверяет актуальность списка микросервисов на архитектуре и в [конфигурации инфраструктуры](resources/kubernetes/microservices)
-2. [find diff in configs and uml dependencies](examples/banking-plantuml/architecture.test.ts) — проверяет актуальность зависимостей (связей) микросервисов на архитектуре и в [конфигурации инфраструктуры](resources/kubernetes/microservices)
-3. [check that urls and topics from relations exist in config](examples/banking-plantuml/architecture.test.ts) — проверяет соответствие между параметрами связей микросервисов (REST-урлы, топики kafka) на архитектуре и в [конфигурации инфраструктуры](resources/kubernetes/microservices)
+1. [find diff in configs and uml containers](examples/banking-plantuml/architecture.test.ts) — проверяет актуальность списка микросервисов на архитектуре и в [конфигурации инфраструктуры](fixtures/kubernetes/microservices)
+2. [find diff in configs and uml dependencies](examples/banking-plantuml/architecture.test.ts) — проверяет актуальность зависимостей (связей) микросервисов на архитектуре и в [конфигурации инфраструктуры](fixtures/kubernetes/microservices)
+3. [check that urls and topics from relations exist in config](examples/banking-plantuml/architecture.test.ts) — проверяет соответствие между параметрами связей микросервисов (REST-урлы, топики kafka) на архитектуре и в [конфигурации инфраструктуры](fixtures/kubernetes/microservices)
 4. [only acl can depend on external systems](test/rules/acl.test.ts) — проверяет, что не нарушен выбранный принцип построения интеграций с внешними системами только через ACL (Anti Corruption Layer). Проверяет, что только acl-микросервисы имеют зависимости от внешних систем.
 5. [connect to external systems only by API Gateway or kafka](examples/banking-plantuml/architecture.test.ts) — проверяет, что все внешние интеграции идут через API Gateway или через kafka
 
@@ -190,11 +222,11 @@ https://www.youtube.com/watch?v=fb2UjqjHGUE
 
 ### Ручная:
 
-[![C4](resources/architecture/Demo%20Tests.svg)](resources/architecture/Demo%20Tests.svg)
+[![C4](fixtures/architecture/Demo%20Tests.svg)](fixtures/architecture/Demo%20Tests.svg)
 
 ### Сгенерированная:
 
-[![C4](resources/architecture/Demo%20Generated.svg)](resources/architecture/Demo%20Generated.svg)
+[![C4](fixtures/architecture/Demo%20Generated.svg)](fixtures/architecture/Demo%20Generated.svg)
 
 # Тестирование модульного монолита
 

package/dist/chunks/index.mjs

@@ -0,0 +1,422 @@
+import { p as getBoundary, q as getContainer } from '../shared/aact.CxegP3pU.mjs';
+import fs from 'node:fs/promises';
+import path from 'pathe';
+import { Comment, Stdlib_C4_Container_Component, Stdlib_C4_Context, Stdlib_C4_Dynamic_Rel, Relationship, Stdlib_C4_Boundary, parse } from 'plantuml-parser';
+import { p as parseCsvTags } from '../shared/aact.BpV1UCZJ.mjs';
+import { b as buildModel } from '../shared/aact.CfImn7en.mjs';
+import 'valibot';
+import 'consola';
+
+const C4_KIND_MAP = Object.freeze({
+  // Person
+  Person: { kind: "Person", external: false },
+  Person_Ext: { kind: "Person", external: true },
+  // System / SystemDb / SystemQueue + _Ext variants
+  System: { kind: "System", external: false },
+  SystemDb: { kind: "System", external: false },
+  SystemQueue: { kind: "System", external: false },
+  System_Ext: { kind: "System", external: true },
+  SystemDb_Ext: { kind: "System", external: true },
+  SystemQueue_Ext: { kind: "System", external: true },
+  // Container variants
+  Container: { kind: "Container", external: false },
+  ContainerDb: { kind: "ContainerDb", external: false },
+  ContainerQueue: { kind: "ContainerQueue", external: false },
+  Container_Ext: { kind: "Container", external: true },
+  ContainerDb_Ext: { kind: "ContainerDb", external: true },
+  ContainerQueue_Ext: { kind: "ContainerQueue", external: true },
+  // Component variants
+  Component: { kind: "Component", external: false },
+  ComponentDb: { kind: "ComponentDb", external: false },
+  ComponentQueue: { kind: "ComponentQueue", external: false },
+  Component_Ext: { kind: "Component", external: true },
+  ComponentDb_Ext: { kind: "ComponentDb", external: true },
+  ComponentQueue_Ext: { kind: "ComponentQueue", external: true }
+});
+const parseC4MacroKind = (macroName) => C4_KIND_MAP[macroName];
+const BOUNDARY_KIND_MAP = Object.freeze(
+  {
+    Boundary: "System",
+    // generic — sensible default
+    System_Boundary: "System",
+    Container_Boundary: "Container",
+    Component_Boundary: "Component",
+    Enterprise_Boundary: "Enterprise"
+  }
+);
+const parseBoundaryMacro = (macroName) => BOUNDARY_KIND_MAP[macroName] ?? "System";
+const c4MacroName = (kind, external) => {
+  if (kind === "Person") return external ? "Person_Ext" : "Person";
+  if (kind === "System") return external ? "System_Ext" : "System";
+  return external ? `${kind}_Ext` : kind;
+};
+const boundaryMacroName = (kind) => {
+  if (kind === "System") return "System_Boundary";
+  if (kind === "Container") return "Container_Boundary";
+  if (kind === "Component") return "Component_Boundary";
+  return "Enterprise_Boundary";
+};
+
+const isContextKind = (kind) => kind === "Person" || kind === "System";
+const renderContainer = (container) => {
+  const macro = c4MacroName(container.kind, container.external);
+  const parts = [container.name, `"${container.label}"`];
+  if (isContextKind(container.kind)) {
+    if (container.description) parts.push(`"${container.description}"`);
+  } else {
+    if (container.technology) parts.push(`"${container.technology}"`);
+    else if (container.description) parts.push('""');
+    if (container.description) parts.push(`"${container.description}"`);
+  }
+  const named = [];
+  if (container.sprite) named.push(`$sprite="${container.sprite}"`);
+  if (container.tags.length > 0)
+    named.push(`$tags="${container.tags.join("+")}"`);
+  if (container.link) named.push(`$link="${container.link}"`);
+  return `${macro}(${[...parts, ...named].join(", ")})`;
+};
+const renderBoundary = (model, boundary, indent) => {
+  const inner = indent + "  ";
+  const macro = boundaryMacroName(boundary.kind);
+  const childBoundaries = boundary.boundaryNames.map((name) => getBoundary(model, name)).filter((b) => b !== void 0).map((b) => renderBoundary(model, b, inner));
+  const childContainers = boundary.containerNames.map((name) => getContainer(model, name)).filter((c) => c !== void 0).map((c) => `${inner}${renderContainer(c)}`);
+  const parts = [boundary.name, `"${boundary.label}"`];
+  const named = [];
+  if (boundary.tags.length > 0)
+    named.push(`$tags="${boundary.tags.join("+")}"`);
+  if (boundary.link) named.push(`$link="${boundary.link}"`);
+  return [
+    `${indent}${macro}(${[...parts, ...named].join(", ")}) {`,
+    ...childBoundaries,
+    ...childContainers,
+    `${indent}}`
+  ].join("\n");
+};
+const renderRelation = (from, relation) => {
+  const label = relation.description ?? "";
+  const parts = [from, relation.to, `"${label}"`];
+  if (relation.technology) parts.push(`"${relation.technology}"`);
+  const named = [];
+  if (relation.sprite) named.push(`$sprite="${relation.sprite}"`);
+  if (relation.tags.length > 0)
+    named.push(`$tags="${relation.tags.join("+")}"`);
+  if (relation.link) named.push(`$link="${relation.link}"`);
+  return `Rel(${[...parts, ...named].join(", ")})`;
+};
+const collectBoundedContainerNames = (model) => {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (boundary) => {
+    for (const n of boundary.containerNames) names.add(n);
+    for (const child of boundary.boundaryNames) {
+      const b = getBoundary(model, child);
+      if (b) visit(b);
+    }
+  };
+  for (const root of model.rootBoundaryNames) {
+    const b = getBoundary(model, root);
+    if (b) visit(b);
+  }
+  return names;
+};
+const renderBody = (model, standaloneContainers, boundaryLabel) => {
+  const rootBoundaries = model.rootBoundaryNames.map((n) => getBoundary(model, n)).filter((b) => b !== void 0);
+  if (boundaryLabel) {
+    return [
+      `Boundary(project, "${boundaryLabel}") {`,
+      ...rootBoundaries.map((b) => renderBoundary(model, b, "  ")),
+      ...standaloneContainers.map((c) => `  ${renderContainer(c)}`),
+      `}`
+    ];
+  }
+  return [
+    ...rootBoundaries.map((b) => renderBoundary(model, b, "")),
+    ...standaloneContainers.map((c) => renderContainer(c))
+  ];
+};
+const generate = (model, options) => {
+  const boundedNames = collectBoundedContainerNames(model);
+  const standalone = Object.values(model.containers).filter(
+    (c) => !boundedNames.has(c.name)
+  );
+  const relations = Object.values(model.containers).flatMap(
+    (container) => container.relations.map((rel) => renderRelation(container.name, rel))
+  );
+  const content = [
+    `@startuml`,
+    `!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml`,
+    `LAYOUT_WITH_LEGEND()`,
+    `AddRelTag("async", $lineStyle = DottedLine())`,
+    "",
+    ...renderBody(model, standalone, options?.boundaryLabel),
+    "",
+    ...relations,
+    "@enduml"
+  ].join("\n");
+  return {
+    files: [{ path: "architecture.puml", content }]
+  };
+};
+
+const CONTAINER_LIKE_NAMES = /* @__PURE__ */ new Set([
+  "Container",
+  "ContainerDb",
+  "ContainerQueue",
+  "Container_Ext",
+  "ContainerDb_Ext",
+  "ContainerQueue_Ext",
+  "Component",
+  "ComponentDb",
+  "ComponentQueue",
+  "Component_Ext",
+  "ComponentDb_Ext",
+  "ComponentQueue_Ext"
+]);
+const CONTEXT_NAMES = /* @__PURE__ */ new Set([
+  "Person",
+  "Person_Ext",
+  "System",
+  "SystemDb",
+  "SystemQueue",
+  "System_Ext",
+  "SystemDb_Ext",
+  "SystemQueue_Ext"
+]);
+const BOUNDARY_NAMES = /* @__PURE__ */ new Set([
+  "Boundary",
+  "System_Boundary",
+  "Container_Boundary",
+  "Component_Boundary",
+  "Enterprise_Boundary"
+]);
+const filterElements = (elements) => {
+  const result = [];
+  for (const element of elements) {
+    if (element instanceof Comment) continue;
+    const typeName = element.type_?.name;
+    if (element instanceof Stdlib_C4_Container_Component && CONTAINER_LIKE_NAMES.has(typeName) || element instanceof Stdlib_C4_Context && CONTEXT_NAMES.has(typeName) || element instanceof Stdlib_C4_Dynamic_Rel || element instanceof Relationship) {
+      result.push(element);
+    }
+    if (element instanceof Stdlib_C4_Boundary && BOUNDARY_NAMES.has(typeName)) {
+      result.push(element, ...filterElements(element.elements));
+    }
+    if (Array.isArray(element)) {
+      result.push(...filterElements(element));
+    }
+  }
+  return result;
+};
+
+const TAGS_MARKER = "__aact_tags__:";
+const LINK_MARKER = "__aact_link__:";
+const SPRITE_MARKER = "__aact_sprite__:";
+const preTransformNamedArgs = (raw) => raw.replaceAll(/, \$tags="(.+?)"/g, `, "${TAGS_MARKER}$1"`).replaceAll(/, \$link="(.+?)"/g, `, "${LINK_MARKER}$1"`).replaceAll(/, \$sprite="(.+?)"/g, `, "${SPRITE_MARKER}$1"`).replaceAll('""', '" "');
+const stripMarker = (value, marker) => value && value.startsWith(marker) ? value.slice(marker.length) : void 0;
+const extractMarked = (marker, ...slots) => {
+  for (const slot of slots) {
+    const v = stripMarker(slot, marker);
+    if (v !== void 0) return v;
+  }
+  return void 0;
+};
+const cleanSlot = (value, ...markers) => {
+  if (!value) return void 0;
+  if (markers.some((m) => value.startsWith(m))) return void 0;
+  return value;
+};
+const normalizeRelBack = (elements) => {
+  for (const element of elements) {
+    if (element instanceof Comment) continue;
+    if (!(element instanceof Stdlib_C4_Dynamic_Rel)) continue;
+    if (element.type_.name.startsWith("Rel_Back")) {
+      const from = element.from;
+      element.from = element.to;
+      element.to = from;
+    }
+  }
+};
+const ALL_MARKERS = [TAGS_MARKER, LINK_MARKER, SPRITE_MARKER];
+const buildContainer = (el) => {
+  const macroKind = parseC4MacroKind(el.type_.name);
+  const kind = macroKind?.kind ?? "Container";
+  const external = macroKind?.external ?? false;
+  const rawTechn = "techn" in el && typeof el.techn === "string" ? el.techn : void 0;
+  const taggedValue = extractMarked(
+    TAGS_MARKER,
+    rawTechn,
+    el.descr,
+    el.sprite,
+    el.tags,
+    el.link
+  );
+  const linkValue = extractMarked(
+    LINK_MARKER,
+    rawTechn,
+    el.descr,
+    el.sprite,
+    el.tags,
+    el.link
+  );
+  const spriteNamedValue = extractMarked(
+    SPRITE_MARKER,
+    rawTechn,
+    el.descr,
+    el.sprite,
+    el.tags,
+    el.link
+  );
+  return {
+    name: el.alias,
+    label: el.label,
+    kind,
+    external,
+    description: cleanSlot(el.descr, ...ALL_MARKERS) ?? "",
+    technology: cleanSlot(rawTechn, ...ALL_MARKERS),
+    tags: taggedValue === void 0 ? parseCsvTags(cleanSlot(el.tags, ...ALL_MARKERS)) : parseCsvTags(taggedValue),
+    sprite: spriteNamedValue ?? cleanSlot(el.sprite, ...ALL_MARKERS),
+    relations: [],
+    link: linkValue ?? cleanSlot(el.link, ...ALL_MARKERS)
+  };
+};
+const buildRelation = (rel) => {
+  const taggedValue = extractMarked(
+    TAGS_MARKER,
+    rel.techn,
+    rel.descr,
+    rel.sprite,
+    rel.tags,
+    rel.link
+  );
+  const linkValue = extractMarked(
+    LINK_MARKER,
+    rel.techn,
+    rel.descr,
+    rel.sprite,
+    rel.tags,
+    rel.link
+  );
+  const spriteNamedValue = extractMarked(
+    SPRITE_MARKER,
+    rel.techn,
+    rel.descr,
+    rel.sprite,
+    rel.tags,
+    rel.link
+  );
+  return {
+    to: rel.to,
+    description: cleanSlot(rel.label, ...ALL_MARKERS) || void 0,
+    technology: cleanSlot(rel.techn, ...ALL_MARKERS),
+    tags: taggedValue === void 0 ? parseCsvTags(
+      cleanSlot(rel.descr, ...ALL_MARKERS) || cleanSlot(rel.tags, ...ALL_MARKERS)
+    ) : parseCsvTags(taggedValue),
+    sprite: spriteNamedValue ?? cleanSlot(rel.sprite, ...ALL_MARKERS),
+    link: linkValue ?? cleanSlot(rel.link, ...ALL_MARKERS)
+  };
+};
+const buildBoundary = (el, childContainers, childBoundaries) => {
+  const taggedValue = extractMarked(TAGS_MARKER, el.tags, el.link);
+  const linkValue = extractMarked(LINK_MARKER, el.tags, el.link);
+  return {
+    name: el.alias,
+    label: el.label,
+    kind: parseBoundaryMacro(el.type_.name),
+    tags: taggedValue === void 0 ? parseCsvTags(cleanSlot(el.tags, ...ALL_MARKERS)) : parseCsvTags(taggedValue),
+    containerNames: childContainers,
+    boundaryNames: childBoundaries,
+    link: linkValue ?? cleanSlot(el.link, ...ALL_MARKERS)
+  };
+};
+const isC4Element = (el) => el instanceof Stdlib_C4_Context || el instanceof Stdlib_C4_Container_Component;
+const collectBoundaryChildren = (el) => {
+  const containers = [];
+  const boundaries = [];
+  for (const child of el.elements) {
+    if (isC4Element(child)) containers.push(child.alias);
+    else if (child instanceof Stdlib_C4_Boundary) boundaries.push(child.alias);
+  }
+  return { containers, boundaries };
+};
+const pushRelation = (acc, sourceName, relation) => {
+  const source = acc[sourceName];
+  if (!source) return;
+  acc[sourceName] = {
+    ...source,
+    relations: [...source.relations, relation]
+  };
+};
+const populateRelations = (elements, acc) => {
+  for (const el of elements) {
+    if (!(el instanceof Stdlib_C4_Dynamic_Rel)) continue;
+    pushRelation(acc, el.from, buildRelation(el));
+    if (el.type_.name.startsWith("BiRel")) {
+      pushRelation(
+        acc,
+        el.to,
+        buildRelation({ ...el, from: el.to, to: el.from })
+      );
+    }
+  }
+};
+const collectChildBoundaryNames = (boundaryElements) => {
+  const childOfBoundary = /* @__PURE__ */ new Set();
+  for (const b of boundaryElements) {
+    for (const child of b.elements) {
+      if (child instanceof Stdlib_C4_Boundary) {
+        childOfBoundary.add(child.alias);
+      }
+    }
+  }
+  return childOfBoundary;
+};
+const load = async (filePath) => {
+  const filepath = path.resolve(filePath);
+  const raw = await fs.readFile(filepath, "utf8");
+  const transformed = preTransformNamedArgs(raw);
+  const [{ elements: rawElements }] = parse(transformed);
+  const elements = filterElements(rawElements);
+  normalizeRelBack(elements);
+  const containerByAlias = /* @__PURE__ */ Object.create(
+    null
+  );
+  for (const el of elements) {
+    if (isC4Element(el)) containerByAlias[el.alias] = buildContainer(el);
+  }
+  populateRelations(elements, containerByAlias);
+  const boundaryElements = elements.filter(
+    (el) => el instanceof Stdlib_C4_Boundary
+  );
+  const childOfBoundary = collectChildBoundaryNames(boundaryElements);
+  const boundaries = boundaryElements.map((b) => {
+    const { containers, boundaries: childBoundaries } = collectBoundaryChildren(b);
+    return buildBoundary(b, containers, childBoundaries);
+  });
+  const rootBoundaryNames = boundaries.map((b) => b.name).filter((name) => !childOfBoundary.has(name));
+  return buildModel({
+    containers: Object.values(containerByAlias),
+    boundaries,
+    rootBoundaryNames
+  });
+};
+
+const plantumlSyntax = {
+  containerPattern: (name) => `(${name},`,
+  containerDecl: (name, label, tags) => {
+    const tagsPart = tags ? `, "", "", $tags="${tags}"` : "";
+    return `Container(${name}, "${label}"${tagsPart})`;
+  },
+  relationPattern: (from, to) => `Rel(${from}, ${to}`,
+  relationDecl: (from, to, tech, tags) => {
+    const tagsPart = tags ? `, $tags="${tags}"` : "";
+    return `Rel(${from}, ${to}, "${tech ?? ""}"${tagsPart})`;
+  }
+};
+
+const plantumlFormat = {
+  name: "plantuml",
+  defaultPattern: "*.puml",
+  load,
+  generate,
+  fix: { syntax: plantumlSyntax }
+};
+
+export { plantumlFormat };