@documentation-robotics/cli 0.1.0

package/dist/core/relationship-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/relationship-registry.ts"],
+  "sourcesContent": ["import type { Relationship } from \"../types/index.js\";\n\n/**\n * Relationship type metadata\n */\nexport interface RelationshipTypeMetadata {\n  id: string;\n  predicate: string;\n  inversePredicate?: string;\n  category: string;\n  description?: string;\n  applicable_layers?: string[];\n}\n\n/**\n * Relationship registry - manages intra-layer relationships and their catalog\n */\nexport class RelationshipRegistry {\n  private relationships: Map<string, Relationship[]>;\n  private relationshipTypes: Map<string, RelationshipTypeMetadata>;\n  private predicateMap: Map<string, RelationshipTypeMetadata>;\n  private layerIndex: Map<string, Relationship[]>;\n\n  constructor() {\n    this.relationships = new Map();\n    this.relationshipTypes = new Map();\n    this.predicateMap = new Map();\n    this.layerIndex = new Map();\n  }\n\n  /**\n   * Register a relationship type\n   */\n  registerType(metadata: RelationshipTypeMetadata): void {\n    this.relationshipTypes.set(metadata.id, metadata);\n    this.predicateMap.set(metadata.predicate, metadata);\n  }\n\n  /**\n   * Get relationship type by ID\n   */\n  getType(id: string): RelationshipTypeMetadata | undefined {\n    return this.relationshipTypes.get(id);\n  }\n\n  /**\n   * Get relationship type by predicate\n   */\n  getTypeByPredicate(predicate: string): RelationshipTypeMetadata | undefined {\n    return this.predicateMap.get(predicate);\n  }\n\n  /**\n   * Add a relationship to the registry\n   */\n  addRelationship(relationship: Relationship): void {\n    // Extract layer from element ID (format: {layer}-{type}-{kebab-case-name})\n    const sourceParts = relationship.source.split(\"-\");\n    const layerKey = sourceParts[0]; // Get layer prefix\n\n    // Add to source index\n    if (!this.relationships.has(relationship.source)) {\n      this.relationships.set(relationship.source, []);\n    }\n    this.relationships.get(relationship.source)!.push(relationship);\n\n    // Add to layer index\n    if (!this.layerIndex.has(layerKey)) {\n      this.layerIndex.set(layerKey, []);\n    }\n    this.layerIndex.get(layerKey)!.push(relationship);\n  }\n\n  /**\n   * Get all relationships from a source element\n   */\n  getRelationshipsFrom(sourceId: string): Relationship[] {\n    return this.relationships.get(sourceId) ?? [];\n  }\n\n  /**\n   * Get all relationships in a layer\n   */\n  getRelationshipsByLayer(layerPrefix: string): Relationship[] {\n    return this.layerIndex.get(layerPrefix) ?? [];\n  }\n\n  /**\n   * Get all relationships with a specific predicate\n   */\n  getRelationshipsByPredicate(predicate: string): Relationship[] {\n    const allRels: Relationship[] = [];\n    for (const rels of this.relationships.values()) {\n      allRels.push(...rels.filter(rel => rel.predicate === predicate));\n    }\n    return allRels;\n  }\n\n  /**\n   * Check if a relationship exists\n   */\n  hasRelationship(sourceId: string, targetId: string, predicate: string): boolean {\n    const rels = this.relationships.get(sourceId) ?? [];\n    return rels.some(\n      rel => rel.target === targetId && rel.predicate === predicate\n    );\n  }\n\n  /**\n   * Get all relationships\n   */\n  getAllRelationships(): Relationship[] {\n    const allRels: Relationship[] = [];\n    for (const rels of this.relationships.values()) {\n      allRels.push(...rels);\n    }\n    return allRels;\n  }\n\n  /**\n   * Get all relationship types\n   */\n  getAllTypes(): RelationshipTypeMetadata[] {\n    return Array.from(this.relationshipTypes.values());\n  }\n\n  /**\n   * Check if a predicate is valid\n   */\n  isValidPredicate(predicate: string): boolean {\n    return this.predicateMap.has(predicate);\n  }\n\n  /**\n   * Get valid predicates for a layer\n   */\n  getValidPredicatesForLayer(layer: string): string[] {\n    const layerPrefix = layer.split(\"-\")[0];\n    return this.getAllTypes()\n      .filter(type =>\n        !type.applicable_layers || type.applicable_layers.includes(layerPrefix)\n      )\n      .map(type => type.predicate);\n  }\n\n  /**\n   * Clear all relationships and types\n   */\n  clear(): void {\n    this.relationships.clear();\n    this.relationshipTypes.clear();\n    this.predicateMap.clear();\n    this.layerIndex.clear();\n  }\n\n  /**\n   * Get statistics about registered relationships\n   */\n  getStats(): {\n    totalRelationships: number;\n    uniquePredicates: number;\n    uniqueLayers: number;\n    totalTypes: number;\n  } {\n    const predicates = new Set<string>();\n    for (const rels of this.relationships.values()) {\n      for (const rel of rels) {\n        predicates.add(rel.predicate);\n      }\n    }\n\n    return {\n      totalRelationships: this.getAllRelationships().length,\n      uniquePredicates: predicates.size,\n      uniqueLayers: this.layerIndex.size,\n      totalTypes: this.relationshipTypes.size,\n    };\n  }\n}\n"],
+  "mappings": "AAiBM,MAAO,qBAAoB;EACvB;EACA;EACA;EACA;EAER,cAAA;AACE,SAAK,gBAAgB,oBAAI,IAAG,GAC5B,KAAK,oBAAoB,oBAAI,IAAG,GAChC,KAAK,eAAe,oBAAI,IAAG,GAC3B,KAAK,aAAa,oBAAI,IAAG;EAC3B;;;;EAKA,aAAa,UAAkC;AAC7C,SAAK,kBAAkB,IAAI,SAAS,IAAI,QAAQ,GAChD,KAAK,aAAa,IAAI,SAAS,WAAW,QAAQ;EACpD;;;;EAKA,QAAQ,IAAU;AAChB,WAAO,KAAK,kBAAkB,IAAI,EAAE;EACtC;;;;EAKA,mBAAmB,WAAiB;AAClC,WAAO,KAAK,aAAa,IAAI,SAAS;EACxC;;;;EAKA,gBAAgB,cAA0B;AAGxC,UAAM,WADc,aAAa,OAAO,MAAM,GAAG,EACpB,CAAC;AAG9B,IAAK,KAAK,cAAc,IAAI,aAAa,MAAM,KAC7C,KAAK,cAAc,IAAI,aAAa,QAAQ,CAAA,CAAE,GAEhD,KAAK,cAAc,IAAI,aAAa,MAAM,EAAG,KAAK,YAAY,GAGzD,KAAK,WAAW,IAAI,QAAQ,KAC/B,KAAK,WAAW,IAAI,UAAU,CAAA,CAAE,GAElC,KAAK,WAAW,IAAI,QAAQ,EAAG,KAAK,YAAY;EAClD;;;;EAKA,qBAAqB,UAAgB;AACnC,WAAO,KAAK,cAAc,IAAI,QAAQ,KAAK,CAAA;EAC7C;;;;EAKA,wBAAwB,aAAmB;AACzC,WAAO,KAAK,WAAW,IAAI,WAAW,KAAK,CAAA;EAC7C;;;;EAKA,4BAA4B,WAAiB;AAC3C,UAAM,UAA0B,CAAA;AAChC,eAAW,QAAQ,KAAK,cAAc,OAAM;AAC1C,cAAQ,KAAK,GAAG,KAAK,OAAO,SAAO,IAAI,cAAc,SAAS,CAAC;AAEjE,WAAO;EACT;;;;EAKA,gBAAgB,UAAkB,UAAkB,WAAiB;AAEnE,YADa,KAAK,cAAc,IAAI,QAAQ,KAAK,CAAA,GACrC,KACV,SAAO,IAAI,WAAW,YAAY,IAAI,cAAc,SAAS;EAEjE;;;;EAKA,sBAAmB;AACjB,UAAM,UAA0B,CAAA;AAChC,eAAW,QAAQ,KAAK,cAAc,OAAM;AAC1C,cAAQ,KAAK,GAAG,IAAI;AAEtB,WAAO;EACT;;;;EAKA,cAAW;AACT,WAAO,MAAM,KAAK,KAAK,kBAAkB,OAAM,CAAE;EACnD;;;;EAKA,iBAAiB,WAAiB;AAChC,WAAO,KAAK,aAAa,IAAI,SAAS;EACxC;;;;EAKA,2BAA2B,OAAa;AACtC,UAAM,cAAc,MAAM,MAAM,GAAG,EAAE,CAAC;AACtC,WAAO,KAAK,YAAW,EACpB,OAAO,UACN,CAAC,KAAK,qBAAqB,KAAK,kBAAkB,SAAS,WAAW,CAAC,EAExE,IAAI,UAAQ,KAAK,SAAS;EAC/B;;;;EAKA,QAAK;AACH,SAAK,cAAc,MAAK,GACxB,KAAK,kBAAkB,MAAK,GAC5B,KAAK,aAAa,MAAK,GACvB,KAAK,WAAW,MAAK;EACvB;;;;EAKA,WAAQ;AAMN,UAAM,aAAa,oBAAI,IAAG;AAC1B,eAAW,QAAQ,KAAK,cAAc,OAAM;AAC1C,iBAAW,OAAO;AAChB,mBAAW,IAAI,IAAI,SAAS;AAIhC,WAAO;MACL,oBAAoB,KAAK,oBAAmB,EAAG;MAC/C,kBAAkB,WAAW;MAC7B,cAAc,KAAK,WAAW;MAC9B,YAAY,KAAK,kBAAkB;;EAEvC;;",
+  "names": []
+}

package/dist/core/relationships.js

@@ -0,0 +1,78 @@
+class Relationships {
+  relationships = [];
+  dirty = !1;
+  constructor(relationships = []) {
+    this.relationships = relationships;
+  }
+  /**
+   * Add a relationship
+   */
+  add(relationship) {
+    this.relationships.push(relationship), this.dirty = !0;
+  }
+  /**
+   * Delete relationships matching criteria
+   */
+  delete(source, target, predicate) {
+    const initialLength = this.relationships.length;
+    this.relationships = this.relationships.filter((rel) => !(rel.source === source && rel.target === target && (!predicate || rel.predicate === predicate)));
+    const deletedCount = initialLength - this.relationships.length;
+    return deletedCount > 0 && (this.dirty = !0), deletedCount;
+  }
+  /**
+   * Delete all relationships involving an element (as source or target)
+   */
+  deleteForElement(elementId) {
+    const initialLength = this.relationships.length;
+    this.relationships = this.relationships.filter((rel) => rel.source !== elementId && rel.target !== elementId);
+    const deletedCount = initialLength - this.relationships.length;
+    return this.dirty = !0, deletedCount;
+  }
+  /**
+   * Get all relationships for an element
+   */
+  getForElement(elementId) {
+    const outgoing = this.relationships.filter((rel) => rel.source === elementId), incoming = this.relationships.filter((rel) => rel.target === elementId);
+    return { outgoing, incoming };
+  }
+  /**
+   * Get all relationships
+   */
+  getAll() {
+    return [...this.relationships];
+  }
+  /**
+   * Find relationships between two elements
+   */
+  find(source, target, predicate) {
+    return this.relationships.filter((rel) => rel.source === source && rel.target === target && (!predicate || rel.predicate === predicate));
+  }
+  /**
+   * Check if relationships have unsaved changes
+   */
+  isDirty() {
+    return this.dirty;
+  }
+  /**
+   * Mark relationships as clean (no unsaved changes)
+   */
+  markClean() {
+    this.dirty = !1;
+  }
+  /**
+   * Serialize to array for YAML
+   */
+  toArray() {
+    return this.relationships;
+  }
+  /**
+   * Load from array (from YAML)
+   */
+  static fromArray(data) {
+    return new Relationships(data);
+  }
+}
+export {
+  Relationships
+};
+//# sourceMappingURL=relationships.js.map

package/dist/core/relationships.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/relationships.ts"],
+  "sourcesContent": ["/**\n * Relationships management for intra-layer and cross-layer relationships\n */\n\nexport interface Relationship {\n  source: string;\n  predicate: string;\n  target: string;\n  category?: 'structural' | 'behavioral';\n  layer: string;\n  targetLayer?: string;\n  properties?: Record<string, unknown>;\n}\n\n/**\n * Relationships class for managing the central relationships.yaml file\n */\nexport class Relationships {\n  private relationships: Relationship[] = [];\n  private dirty: boolean = false;\n\n  constructor(relationships: Relationship[] = []) {\n    this.relationships = relationships;\n  }\n\n  /**\n   * Add a relationship\n   */\n  add(relationship: Relationship): void {\n    this.relationships.push(relationship);\n    this.dirty = true;\n  }\n\n  /**\n   * Delete relationships matching criteria\n   */\n  delete(source: string, target: string, predicate?: string): number {\n    const initialLength = this.relationships.length;\n    this.relationships = this.relationships.filter(\n      (rel) =>\n        !(\n          rel.source === source &&\n          rel.target === target &&\n          (!predicate || rel.predicate === predicate)\n        )\n    );\n    const deletedCount = initialLength - this.relationships.length;\n    if (deletedCount > 0) {\n      this.dirty = true;\n    }\n    return deletedCount;\n  }\n\n  /**\n   * Delete all relationships involving an element (as source or target)\n   */\n  deleteForElement(elementId: string): number {\n    const initialLength = this.relationships.length;\n    this.relationships = this.relationships.filter(\n      (rel) => rel.source !== elementId && rel.target !== elementId\n    );\n    const deletedCount = initialLength - this.relationships.length;\n    // Always mark as dirty to ensure file is rewritten (Python CLI behavior)\n    this.dirty = true;\n    return deletedCount;\n  }\n\n  /**\n   * Get all relationships for an element\n   */\n  getForElement(elementId: string): {\n    outgoing: Relationship[];\n    incoming: Relationship[];\n  } {\n    const outgoing = this.relationships.filter((rel) => rel.source === elementId);\n    const incoming = this.relationships.filter((rel) => rel.target === elementId);\n    return { outgoing, incoming };\n  }\n\n  /**\n   * Get all relationships\n   */\n  getAll(): Relationship[] {\n    return [...this.relationships];\n  }\n\n  /**\n   * Find relationships between two elements\n   */\n  find(source: string, target: string, predicate?: string): Relationship[] {\n    return this.relationships.filter(\n      (rel) =>\n        rel.source === source &&\n        rel.target === target &&\n        (!predicate || rel.predicate === predicate)\n    );\n  }\n\n  /**\n   * Check if relationships have unsaved changes\n   */\n  isDirty(): boolean {\n    return this.dirty;\n  }\n\n  /**\n   * Mark relationships as clean (no unsaved changes)\n   */\n  markClean(): void {\n    this.dirty = false;\n  }\n\n  /**\n   * Serialize to array for YAML\n   */\n  toArray(): Relationship[] {\n    return this.relationships;\n  }\n\n  /**\n   * Load from array (from YAML)\n   */\n  static fromArray(data: Relationship[]): Relationships {\n    return new Relationships(data);\n  }\n}\n"],
+  "mappings": "AAiBM,MAAO,cAAa;EAChB,gBAAgC,CAAA;EAChC,QAAiB;EAEzB,YAAY,gBAAgC,CAAA,GAAE;AAC5C,SAAK,gBAAgB;EACvB;;;;EAKA,IAAI,cAA0B;AAC5B,SAAK,cAAc,KAAK,YAAY,GACpC,KAAK,QAAQ;EACf;;;;EAKA,OAAO,QAAgB,QAAgB,WAAkB;AACvD,UAAM,gBAAgB,KAAK,cAAc;AACzC,SAAK,gBAAgB,KAAK,cAAc,OACtC,CAAC,QACC,EACE,IAAI,WAAW,UACf,IAAI,WAAW,WACd,CAAC,aAAa,IAAI,cAAc,WAClC;AAEL,UAAM,eAAe,gBAAgB,KAAK,cAAc;AACxD,WAAI,eAAe,MACjB,KAAK,QAAQ,KAER;EACT;;;;EAKA,iBAAiB,WAAiB;AAChC,UAAM,gBAAgB,KAAK,cAAc;AACzC,SAAK,gBAAgB,KAAK,cAAc,OACtC,CAAC,QAAQ,IAAI,WAAW,aAAa,IAAI,WAAW,SAAS;AAE/D,UAAM,eAAe,gBAAgB,KAAK,cAAc;AAExD,gBAAK,QAAQ,IACN;EACT;;;;EAKA,cAAc,WAAiB;AAI7B,UAAM,WAAW,KAAK,cAAc,OAAO,CAAC,QAAQ,IAAI,WAAW,SAAS,GACtE,WAAW,KAAK,cAAc,OAAO,CAAC,QAAQ,IAAI,WAAW,SAAS;AAC5E,WAAO,EAAE,UAAU,SAAQ;EAC7B;;;;EAKA,SAAM;AACJ,WAAO,CAAC,GAAG,KAAK,aAAa;EAC/B;;;;EAKA,KAAK,QAAgB,QAAgB,WAAkB;AACrD,WAAO,KAAK,cAAc,OACxB,CAAC,QACC,IAAI,WAAW,UACf,IAAI,WAAW,WACd,CAAC,aAAa,IAAI,cAAc,UAAU;EAEjD;;;;EAKA,UAAO;AACL,WAAO,KAAK;EACd;;;;EAKA,YAAS;AACP,SAAK,QAAQ;EACf;;;;EAKA,UAAO;AACL,WAAO,KAAK;EACd;;;;EAKA,OAAO,UAAU,MAAoB;AACnC,WAAO,IAAI,cAAc,IAAI;EAC/B;;",
+  "names": []
+}

package/dist/export/archimate-exporter.js

@@ -0,0 +1,111 @@
+import { escapeXml } from "./types.js";
+class ArchiMateExporter {
+  name = "ArchiMate";
+  supportedLayers = ["motivation", "business", "application", "technology"];
+  async export(model, options = {}) {
+    const lines = [];
+    lines.push('<?xml version="1.0" encoding="UTF-8"?>'), lines.push('<model xmlns="http://www.opengroup.org/xsd/archimate/3.0/"'), lines.push('       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"'), lines.push('       xsi:schemaLocation="http://www.opengroup.org/xsd/archimate/3.0/ http://www.opengroup.org/xsd/archimate/3.1/archimate3_Diagram.xsd">'), lines.push(`  <name>${escapeXml(model.manifest.name)}</name>`), model.manifest.description && lines.push(`  <documentation>${escapeXml(model.manifest.description)}</documentation>`), lines.push("  <elements>");
+    const layersToExport = options.layers || this.supportedLayers, elements = [];
+    for (const layerName of layersToExport) {
+      if (!this.supportedLayers.includes(layerName))
+        continue;
+      const layer = await model.getLayer(layerName);
+      if (layer)
+        for (const element of layer.listElements())
+          elements.push({ layer: layerName, element });
+    }
+    for (const { layer, element } of elements) {
+      const archiType = this.mapToArchiMateType(element.type, layer);
+      lines.push(`    <element identifier="${element.id}" xsi:type="${archiType}">`), lines.push(`      <name>${escapeXml(element.name)}</name>`), element.description && lines.push(`      <documentation>${escapeXml(element.description)}</documentation>`);
+      const propKeys = Object.keys(element.properties);
+      if (propKeys.length > 0) {
+        const propsStr = propKeys.map((key) => {
+          const val = element.properties[key];
+          return `${key}: ${this.valueToString(val)}`;
+        }).join("; ");
+        propsStr && lines.push(`      <documentation>Properties: ${escapeXml(propsStr)}</documentation>`);
+      }
+      lines.push("    </element>");
+    }
+    lines.push("  </elements>"), lines.push("  <relationships>");
+    for (const { element } of elements) {
+      for (const ref of element.references)
+        lines.push(`    <relationship identifier="${this.escapeId(element.id)}-ref-${this.escapeId(ref.target)}" `), lines.push(`                  source="${element.id}" target="${ref.target}" `), lines.push('                  xsi:type="Association">'), ref.description && lines.push(`      <documentation>${escapeXml(ref.description)}</documentation>`), lines.push(`      <name>${ref.type}</name>`), lines.push("    </relationship>");
+      for (const rel of element.relationships)
+        lines.push(`    <relationship identifier="${this.escapeId(element.id)}-${this.escapeId(rel.predicate)}-${this.escapeId(rel.target)}" `), lines.push(`                  source="${element.id}" target="${rel.target}" `), lines.push('                  xsi:type="Association">'), lines.push(`      <name>${rel.predicate}</name>`), lines.push("    </relationship>");
+    }
+    return lines.push("  </relationships>"), lines.push("</model>"), lines.join(`
+`);
+  }
+  /**
+   * Map element type and layer to ArchiMate type
+   */
+  mapToArchiMateType(type, layer) {
+    return {
+      motivation: {
+        stakeholder: "Stakeholder",
+        driver: "Driver",
+        assessment: "Assessment",
+        goal: "Goal",
+        outcome: "Outcome",
+        principle: "Principle",
+        requirement: "Requirement",
+        constraint: "Constraint"
+      },
+      business: {
+        "business-actor": "BusinessActor",
+        "business-role": "BusinessRole",
+        "business-collaboration": "BusinessCollaboration",
+        "business-interface": "BusinessInterface",
+        "business-process": "BusinessProcess",
+        "business-function": "BusinessFunction",
+        "business-interaction": "BusinessInteraction",
+        "business-event": "BusinessEvent",
+        "business-service": "BusinessService",
+        "business-object": "BusinessObject"
+      },
+      application: {
+        "application-component": "ApplicationComponent",
+        "application-collaboration": "ApplicationCollaboration",
+        "application-interface": "ApplicationInterface",
+        "application-function": "ApplicationFunction",
+        "application-interaction": "ApplicationInteraction",
+        "application-process": "ApplicationProcess",
+        "application-event": "ApplicationEvent",
+        "application-service": "ApplicationService",
+        "data-object": "DataObject"
+      },
+      technology: {
+        node: "Node",
+        device: "Device",
+        "system-software": "SystemSoftware",
+        "technology-collaboration": "TechnologyCollaboration",
+        "technology-interface": "TechnologyInterface",
+        path: "Path",
+        "communication-network": "CommunicationNetwork",
+        "technology-function": "TechnologyFunction",
+        "technology-process": "TechnologyProcess",
+        "technology-interaction": "TechnologyInteraction",
+        "technology-event": "TechnologyEvent",
+        "technology-service": "TechnologyService",
+        artifact: "Artifact"
+      }
+    }[layer]?.[type] || "Element";
+  }
+  /**
+   * Escape ID characters for use in identifiers
+   */
+  escapeId(str) {
+    return str.replace(/[^a-zA-Z0-9_-]/g, "_");
+  }
+  /**
+   * Convert value to string representation
+   */
+  valueToString(value) {
+    return typeof value == "string" ? value : typeof value == "number" || typeof value == "boolean" ? String(value) : Array.isArray(value) ? `[${value.map((v) => this.valueToString(v)).join(", ")}]` : value && typeof value == "object" ? JSON.stringify(value) : String(value);
+  }
+}
+export {
+  ArchiMateExporter
+};
+//# sourceMappingURL=archimate-exporter.js.map

package/dist/export/archimate-exporter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/export/archimate-exporter.ts"],
+  "sourcesContent": ["import type { Model } from \"../core/model.js\";\nimport type { Exporter, ExportOptions } from \"./types.js\";\nimport { escapeXml } from \"./types.js\";\n\n/**\n * ArchiMate XML Exporter for layers 1, 2, 4, 5\n * Generates valid ArchiMate 3.2 XML format\n */\nexport class ArchiMateExporter implements Exporter {\n  name = \"ArchiMate\";\n  supportedLayers = [\"motivation\", \"business\", \"application\", \"technology\"];\n\n  async export(model: Model, options: ExportOptions = {}): Promise<string> {\n    const lines: string[] = [];\n\n    // XML declaration\n    lines.push('<?xml version=\"1.0\" encoding=\"UTF-8\"?>');\n\n    // Root element with namespaces\n    lines.push(\n      '<model xmlns=\"http://www.opengroup.org/xsd/archimate/3.0/\"'\n    );\n    lines.push(\n      '       xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"'\n    );\n    lines.push(\n      '       xsi:schemaLocation=\"http://www.opengroup.org/xsd/archimate/3.0/ http://www.opengroup.org/xsd/archimate/3.1/archimate3_Diagram.xsd\">'\n    );\n\n    // Model metadata\n    lines.push(`  <name>${escapeXml(model.manifest.name)}</name>`);\n    if (model.manifest.description) {\n      lines.push(\n        `  <documentation>${escapeXml(model.manifest.description)}</documentation>`\n      );\n    }\n\n    // Export elements\n    lines.push(\"  <elements>\");\n\n    const layersToExport = options.layers || this.supportedLayers;\n    const elements: Array<{ layer: string; element: any }> = [];\n\n    for (const layerName of layersToExport) {\n      if (!this.supportedLayers.includes(layerName)) continue;\n\n      const layer = await model.getLayer(layerName);\n      if (!layer) continue;\n\n      for (const element of layer.listElements()) {\n        elements.push({ layer: layerName, element });\n      }\n    }\n\n    for (const { layer, element } of elements) {\n      const archiType = this.mapToArchiMateType(element.type, layer);\n      lines.push(`    <element identifier=\"${element.id}\" xsi:type=\"${archiType}\">`);\n      lines.push(`      <name>${escapeXml(element.name)}</name>`);\n\n      if (element.description) {\n        lines.push(\n          `      <documentation>${escapeXml(element.description)}</documentation>`\n        );\n      }\n\n      // Add properties as additional attributes or documentation\n      const propKeys = Object.keys(element.properties);\n      if (propKeys.length > 0) {\n        const propsStr = propKeys\n          .map((key) => {\n            const val = element.properties[key];\n            return `${key}: ${this.valueToString(val)}`;\n          })\n          .join(\"; \");\n        if (propsStr) {\n          lines.push(\n            `      <documentation>Properties: ${escapeXml(propsStr)}</documentation>`\n          );\n        }\n      }\n\n      lines.push(\"    </element>\");\n    }\n\n    lines.push(\"  </elements>\");\n\n    // Export relationships and references\n    lines.push(\"  <relationships>\");\n\n    for (const { element } of elements) {\n      // Handle cross-layer references\n      for (const ref of element.references) {\n        lines.push(\n          `    <relationship identifier=\"${this.escapeId(element.id)}-ref-${this.escapeId(ref.target)}\" `\n        );\n        lines.push(`                  source=\"${element.id}\" target=\"${ref.target}\" `);\n        lines.push(`                  xsi:type=\"Association\">`);\n        if (ref.description) {\n          lines.push(\n            `      <documentation>${escapeXml(ref.description)}</documentation>`\n          );\n        }\n        lines.push(`      <name>${ref.type}</name>`);\n        lines.push(`    </relationship>`);\n      }\n\n      // Handle intra-layer relationships\n      for (const rel of element.relationships) {\n        lines.push(\n          `    <relationship identifier=\"${this.escapeId(element.id)}-${this.escapeId(rel.predicate)}-${this.escapeId(rel.target)}\" `\n        );\n        lines.push(`                  source=\"${element.id}\" target=\"${rel.target}\" `);\n        lines.push(`                  xsi:type=\"Association\">`);\n        lines.push(`      <name>${rel.predicate}</name>`);\n        lines.push(`    </relationship>`);\n      }\n    }\n\n    lines.push(\"  </relationships>\");\n    lines.push(\"</model>\");\n\n    return lines.join(\"\\n\");\n  }\n\n  /**\n   * Map element type and layer to ArchiMate type\n   */\n  private mapToArchiMateType(type: string, layer: string): string {\n    const mapping: Record<string, Record<string, string>> = {\n      motivation: {\n        stakeholder: \"Stakeholder\",\n        driver: \"Driver\",\n        assessment: \"Assessment\",\n        goal: \"Goal\",\n        outcome: \"Outcome\",\n        principle: \"Principle\",\n        requirement: \"Requirement\",\n        constraint: \"Constraint\",\n      },\n      business: {\n        \"business-actor\": \"BusinessActor\",\n        \"business-role\": \"BusinessRole\",\n        \"business-collaboration\": \"BusinessCollaboration\",\n        \"business-interface\": \"BusinessInterface\",\n        \"business-process\": \"BusinessProcess\",\n        \"business-function\": \"BusinessFunction\",\n        \"business-interaction\": \"BusinessInteraction\",\n        \"business-event\": \"BusinessEvent\",\n        \"business-service\": \"BusinessService\",\n        \"business-object\": \"BusinessObject\",\n      },\n      application: {\n        \"application-component\": \"ApplicationComponent\",\n        \"application-collaboration\": \"ApplicationCollaboration\",\n        \"application-interface\": \"ApplicationInterface\",\n        \"application-function\": \"ApplicationFunction\",\n        \"application-interaction\": \"ApplicationInteraction\",\n        \"application-process\": \"ApplicationProcess\",\n        \"application-event\": \"ApplicationEvent\",\n        \"application-service\": \"ApplicationService\",\n        \"data-object\": \"DataObject\",\n      },\n      technology: {\n        node: \"Node\",\n        device: \"Device\",\n        \"system-software\": \"SystemSoftware\",\n        \"technology-collaboration\": \"TechnologyCollaboration\",\n        \"technology-interface\": \"TechnologyInterface\",\n        path: \"Path\",\n        \"communication-network\": \"CommunicationNetwork\",\n        \"technology-function\": \"TechnologyFunction\",\n        \"technology-process\": \"TechnologyProcess\",\n        \"technology-interaction\": \"TechnologyInteraction\",\n        \"technology-event\": \"TechnologyEvent\",\n        \"technology-service\": \"TechnologyService\",\n        artifact: \"Artifact\",\n      },\n    };\n\n    return mapping[layer]?.[type] || \"Element\";\n  }\n\n  /**\n   * Escape ID characters for use in identifiers\n   */\n  private escapeId(str: string): string {\n    return str.replace(/[^a-zA-Z0-9_-]/g, \"_\");\n  }\n\n  /**\n   * Convert value to string representation\n   */\n  private valueToString(value: unknown): string {\n    if (typeof value === \"string\") return value;\n    if (typeof value === \"number\") return String(value);\n    if (typeof value === \"boolean\") return String(value);\n    if (Array.isArray(value)) return `[${value.map((v) => this.valueToString(v)).join(\", \")}]`;\n    if (value && typeof value === \"object\") {\n      return JSON.stringify(value);\n    }\n    return String(value);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/export/export-manager.js

@@ -0,0 +1,63 @@
+class ExportManager {
+  exporters = /* @__PURE__ */ new Map();
+  formatInfo = /* @__PURE__ */ new Map();
+  /**
+   * Register an exporter for a specific format
+   */
+  register(format, exporter, info) {
+    this.exporters.set(format, exporter), this.formatInfo.set(format, {
+      format,
+      name: exporter.name,
+      supportedLayers: exporter.supportedLayers,
+      ...info
+    });
+  }
+  /**
+   * Check if a format is registered
+   */
+  hasFormat(format) {
+    return this.exporters.has(format);
+  }
+  /**
+   * Export model to specified format
+   */
+  async export(model, format, options = {}) {
+    const exporter = this.exporters.get(format);
+    if (!exporter)
+      throw new Error(`Unknown export format: ${format}`);
+    if (options.layers) {
+      const unsupported = options.layers.filter((layer) => !exporter.supportedLayers.includes(layer));
+      if (unsupported.length > 0)
+        throw new Error(`Format '${format}' does not support layers: ${unsupported.join(", ")}. Supported layers: ${exporter.supportedLayers.join(", ")}`);
+    }
+    return await exporter.export(model, options);
+  }
+  /**
+   * Get list of available formats
+   */
+  listFormats() {
+    return Array.from(this.exporters.keys()).sort();
+  }
+  /**
+   * Get metadata about a format
+   */
+  getFormatInfo(format) {
+    return this.formatInfo.get(format);
+  }
+  /**
+   * Get supported layers for a format
+   */
+  getSupportedLayers(format) {
+    return this.exporters.get(format)?.supportedLayers ?? [];
+  }
+  /**
+   * Get all registered formats with metadata
+   */
+  getAllFormats() {
+    return Array.from(this.formatInfo.values()).sort((a, b) => a.format.localeCompare(b.format));
+  }
+}
+export {
+  ExportManager
+};
+//# sourceMappingURL=export-manager.js.map

package/dist/export/export-manager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/export/export-manager.ts"],
+  "sourcesContent": ["import type { Model } from \"../core/model.js\";\nimport type { Exporter, ExportOptions, ExportFormatInfo } from \"./types.js\";\n\n/**\n * ExportManager - Registry and dispatcher for format-specific exporters\n */\nexport class ExportManager {\n  private exporters: Map<string, Exporter> = new Map();\n  private formatInfo: Map<string, ExportFormatInfo> = new Map();\n\n  /**\n   * Register an exporter for a specific format\n   */\n  register(\n    format: string,\n    exporter: Exporter,\n    info: Omit<ExportFormatInfo, 'format' | 'name' | 'supportedLayers'>\n  ): void {\n    this.exporters.set(format, exporter);\n    this.formatInfo.set(format, {\n      format,\n      name: exporter.name,\n      supportedLayers: exporter.supportedLayers,\n      ...info,\n    });\n  }\n\n  /**\n   * Check if a format is registered\n   */\n  hasFormat(format: string): boolean {\n    return this.exporters.has(format);\n  }\n\n  /**\n   * Export model to specified format\n   */\n  async export(\n    model: Model,\n    format: string,\n    options: ExportOptions = {}\n  ): Promise<string> {\n    const exporter = this.exporters.get(format);\n    if (!exporter) {\n      throw new Error(`Unknown export format: ${format}`);\n    }\n\n    // Validate that requested layers are supported\n    if (options.layers) {\n      const unsupported = options.layers.filter(\n        (layer) => !exporter.supportedLayers.includes(layer)\n      );\n      if (unsupported.length > 0) {\n        throw new Error(\n          `Format '${format}' does not support layers: ${unsupported.join(', ')}. ` +\n          `Supported layers: ${exporter.supportedLayers.join(', ')}`\n        );\n      }\n    }\n\n    return await exporter.export(model, options);\n  }\n\n  /**\n   * Get list of available formats\n   */\n  listFormats(): string[] {\n    return Array.from(this.exporters.keys()).sort();\n  }\n\n  /**\n   * Get metadata about a format\n   */\n  getFormatInfo(format: string): ExportFormatInfo | undefined {\n    return this.formatInfo.get(format);\n  }\n\n  /**\n   * Get supported layers for a format\n   */\n  getSupportedLayers(format: string): string[] {\n    const exporter = this.exporters.get(format);\n    return exporter?.supportedLayers ?? [];\n  }\n\n  /**\n   * Get all registered formats with metadata\n   */\n  getAllFormats(): ExportFormatInfo[] {\n    return Array.from(this.formatInfo.values()).sort((a, b) =>\n      a.format.localeCompare(b.format)\n    );\n  }\n}\n"],
+  "mappings": "AAMM,MAAO,cAAa;EAChB,YAAmC,oBAAI,IAAG;EAC1C,aAA4C,oBAAI,IAAG;;;;EAK3D,SACE,QACA,UACA,MAAmE;AAEnE,SAAK,UAAU,IAAI,QAAQ,QAAQ,GACnC,KAAK,WAAW,IAAI,QAAQ;MAC1B;MACA,MAAM,SAAS;MACf,iBAAiB,SAAS;MAC1B,GAAG;KACJ;EACH;;;;EAKA,UAAU,QAAc;AACtB,WAAO,KAAK,UAAU,IAAI,MAAM;EAClC;;;;EAKA,MAAM,OACJ,OACA,QACA,UAAyB,CAAA,GAAE;AAE3B,UAAM,WAAW,KAAK,UAAU,IAAI,MAAM;AAC1C,QAAI,CAAC;AACH,YAAM,IAAI,MAAM,0BAA0B,MAAM,EAAE;AAIpD,QAAI,QAAQ,QAAQ;AAClB,YAAM,cAAc,QAAQ,OAAO,OACjC,CAAC,UAAU,CAAC,SAAS,gBAAgB,SAAS,KAAK,CAAC;AAEtD,UAAI,YAAY,SAAS;AACvB,cAAM,IAAI,MACR,WAAW,MAAM,8BAA8B,YAAY,KAAK,IAAI,CAAC,uBAChD,SAAS,gBAAgB,KAAK,IAAI,CAAC,EAAE;IAGhE;AAEA,WAAO,MAAM,SAAS,OAAO,OAAO,OAAO;EAC7C;;;;EAKA,cAAW;AACT,WAAO,MAAM,KAAK,KAAK,UAAU,KAAI,CAAE,EAAE,KAAI;EAC/C;;;;EAKA,cAAc,QAAc;AAC1B,WAAO,KAAK,WAAW,IAAI,MAAM;EACnC;;;;EAKA,mBAAmB,QAAc;AAE/B,WADiB,KAAK,UAAU,IAAI,MAAM,GACzB,mBAAmB,CAAA;EACtC;;;;EAKA,gBAAa;AACX,WAAO,MAAM,KAAK,KAAK,WAAW,OAAM,CAAE,EAAE,KAAK,CAAC,GAAG,MACnD,EAAE,OAAO,cAAc,EAAE,MAAM,CAAC;EAEpC;;",
+  "names": []
+}

package/dist/export/graphml-exporter.js

@@ -0,0 +1,39 @@
+import { ALL_LAYERS, LAYER_COLORS, escapeXml } from "./types.js";
+class GraphMLExporter {
+  name = "GraphML";
+  supportedLayers = ALL_LAYERS;
+  async export(model, options = {}) {
+    const lines = [];
+    lines.push('<?xml version="1.0" encoding="UTF-8"?>'), lines.push('<graphml xmlns="http://graphml.graphdrawing.org/xmlns"'), lines.push('         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"'), lines.push('         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd"'), lines.push('         edgedefault="directed">'), lines.push('  <key id="node_description" for="node" attr.name="description" attr.type="string"/>'), lines.push('  <key id="node_layer" for="node" attr.name="layer" attr.type="string"/>'), lines.push('  <key id="node_type" for="node" attr.name="type" attr.type="string"/>'), lines.push('  <key id="edge_type" for="edge" attr.name="type" attr.type="string"/>'), lines.push('  <graph id="model" edgedefault="directed">'), lines.push(`    <data key="name">${escapeXml(model.manifest.name)}</data>`);
+    const layersToExport = options.layers || this.supportedLayers, elementMap = /* @__PURE__ */ new Map();
+    for (const layerName of layersToExport) {
+      const layer = await model.getLayer(layerName);
+      if (layer)
+        for (const element of layer.listElements()) {
+          const color = `#${LAYER_COLORS[layerName] || "FFFFFF"}`;
+          lines.push(`    <node id="${element.id}">`), lines.push(`      <data key="name">${escapeXml(element.name)}</data>`), lines.push(`      <data key="node_layer">${layerName}</data>`), lines.push(`      <data key="node_type">${element.type}</data>`), element.description && lines.push(`      <data key="node_description">${escapeXml(element.description)}</data>`), lines.push(`      <graphics x="0" y="0" w="150" h="50" fill="${color}" type="rectangle"/>`), lines.push('      <data key="d6">'), lines.push("        <y:ShapeNode>"), lines.push(`          <y:NodeLabel>${escapeXml(element.name)}</y:NodeLabel>`), lines.push("        </y:ShapeNode>"), lines.push("      </data>"), lines.push("    </node>"), elementMap.set(element.id, {
+            layer: layerName,
+            type: element.type,
+            description: element.description
+          });
+        }
+    }
+    let edgeCounter = 0;
+    for (const layerName of layersToExport) {
+      const layer = await model.getLayer(layerName);
+      if (layer)
+        for (const element of layer.listElements()) {
+          for (const ref of element.references)
+            elementMap.has(ref.target) && (lines.push(`    <edge id="e${edgeCounter}" source="${element.id}" target="${ref.target}">`), lines.push(`      <data key="edge_type">${ref.type}</data>`), lines.push(`      <data key="name">${escapeXml(ref.type)}</data>`), ref.description && lines.push(`      <data key="description">${escapeXml(ref.description)}</data>`), lines.push("    </edge>"), edgeCounter++);
+          for (const rel of element.relationships)
+            elementMap.has(rel.target) && (lines.push(`    <edge id="e${edgeCounter}" source="${element.id}" target="${rel.target}">`), lines.push(`      <data key="edge_type">${rel.predicate}</data>`), lines.push(`      <data key="name">${escapeXml(rel.predicate)}</data>`), lines.push("    </edge>"), edgeCounter++);
+        }
+    }
+    return lines.push("  </graph>"), lines.push("</graphml>"), lines.join(`
+`);
+  }
+}
+export {
+  GraphMLExporter
+};
+//# sourceMappingURL=graphml-exporter.js.map

package/dist/export/graphml-exporter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/export/graphml-exporter.ts"],
+  "sourcesContent": ["import type { Model } from \"../core/model.js\";\nimport type { Exporter, ExportOptions } from \"./types.js\";\nimport { ALL_LAYERS, LAYER_COLORS, escapeXml } from \"./types.js\";\n\n/**\n * GraphML Exporter - generates GraphML format for graph visualization tools\n * GraphML is an XML-based format supported by tools like yEd, Cytoscape, etc.\n */\nexport class GraphMLExporter implements Exporter {\n  name = \"GraphML\";\n  supportedLayers = ALL_LAYERS;\n\n  async export(model: Model, options: ExportOptions = {}): Promise<string> {\n    const lines: string[] = [];\n\n    // XML declaration\n    lines.push('<?xml version=\"1.0\" encoding=\"UTF-8\"?>');\n\n    // GraphML root element\n    lines.push(\n      '<graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\"'\n    );\n    lines.push(\n      '         xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"'\n    );\n    lines.push(\n      '         xsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd\"'\n    );\n    lines.push('         edgedefault=\"directed\">');\n\n    // Define graph attributes\n    lines.push('  <key id=\"node_description\" for=\"node\" attr.name=\"description\" attr.type=\"string\"/>');\n    lines.push('  <key id=\"node_layer\" for=\"node\" attr.name=\"layer\" attr.type=\"string\"/>');\n    lines.push('  <key id=\"node_type\" for=\"node\" attr.name=\"type\" attr.type=\"string\"/>');\n    lines.push('  <key id=\"edge_type\" for=\"edge\" attr.name=\"type\" attr.type=\"string\"/>');\n\n    // Create main graph\n    lines.push(\n      `  <graph id=\"model\" edgedefault=\"directed\">`\n    );\n    lines.push(\n      `    <data key=\"name\">${escapeXml(model.manifest.name)}</data>`\n    );\n\n    const layersToExport = options.layers || this.supportedLayers;\n    const elementMap = new Map<string, { layer: string; type: string; description?: string }>();\n\n    // Add all nodes (elements)\n    for (const layerName of layersToExport) {\n      const layer = await model.getLayer(layerName);\n      if (!layer) continue;\n\n      for (const element of layer.listElements()) {\n        const color = `#${LAYER_COLORS[layerName] || \"FFFFFF\"}`;\n\n        lines.push(`    <node id=\"${element.id}\">`);\n        lines.push(`      <data key=\"name\">${escapeXml(element.name)}</data>`);\n        lines.push(`      <data key=\"node_layer\">${layerName}</data>`);\n        lines.push(`      <data key=\"node_type\">${element.type}</data>`);\n\n        if (element.description) {\n          lines.push(\n            `      <data key=\"node_description\">${escapeXml(element.description)}</data>`\n          );\n        }\n\n        // Add visualization hints using yEd extensions (optional)\n        lines.push(`      <graphics x=\"0\" y=\"0\" w=\"150\" h=\"50\" fill=\"${color}\" type=\"rectangle\"/>`);\n        lines.push(`      <data key=\"d6\">`);\n        lines.push(`        <y:ShapeNode>`);\n        lines.push(`          <y:NodeLabel>${escapeXml(element.name)}</y:NodeLabel>`);\n        lines.push(`        </y:ShapeNode>`);\n        lines.push(`      </data>`);\n\n        lines.push(`    </node>`);\n\n        elementMap.set(element.id, {\n          layer: layerName,\n          type: element.type,\n          description: element.description,\n        });\n      }\n    }\n\n    // Add all edges (relationships and references)\n    let edgeCounter = 0;\n\n    for (const layerName of layersToExport) {\n      const layer = await model.getLayer(layerName);\n      if (!layer) continue;\n\n      for (const element of layer.listElements()) {\n        // Cross-layer references\n        for (const ref of element.references) {\n          if (!elementMap.has(ref.target)) {\n            // Log warning for dangling reference (in verbose mode this could be extended)\n            continue;\n          }\n          lines.push(\n            `    <edge id=\"e${edgeCounter}\" source=\"${element.id}\" target=\"${ref.target}\">`\n          );\n          lines.push(`      <data key=\"edge_type\">${ref.type}</data>`);\n          lines.push(`      <data key=\"name\">${escapeXml(ref.type)}</data>`);\n\n          if (ref.description) {\n            lines.push(\n              `      <data key=\"description\">${escapeXml(ref.description)}</data>`\n            );\n          }\n\n          lines.push(`    </edge>`);\n          edgeCounter++;\n        }\n\n        // Intra-layer relationships\n        for (const rel of element.relationships) {\n          if (!elementMap.has(rel.target)) {\n            // Skip relationships to non-existent targets\n            continue;\n          }\n          lines.push(\n            `    <edge id=\"e${edgeCounter}\" source=\"${element.id}\" target=\"${rel.target}\">`\n          );\n          lines.push(`      <data key=\"edge_type\">${rel.predicate}</data>`);\n          lines.push(`      <data key=\"name\">${escapeXml(rel.predicate)}</data>`);\n          lines.push(`    </edge>`);\n          edgeCounter++;\n        }\n      }\n    }\n\n    lines.push(`  </graph>`);\n    lines.push(`</graphml>`);\n\n    return lines.join(\"\\n\");\n  }\n}\n"],
+  "mappings": "AAEA,SAAS,YAAY,cAAc,iBAAiB;AAM9C,MAAO,gBAAe;EAC1B,OAAO;EACP,kBAAkB;EAElB,MAAM,OAAO,OAAc,UAAyB,CAAA,GAAE;AACpD,UAAM,QAAkB,CAAA;AAGxB,UAAM,KAAK,wCAAwC,GAGnD,MAAM,KACJ,wDAAwD,GAE1D,MAAM,KACJ,gEAAgE,GAElE,MAAM,KACJ,qFAAqF,GAEvF,MAAM,KAAK,kCAAkC,GAG7C,MAAM,KAAK,sFAAsF,GACjG,MAAM,KAAK,0EAA0E,GACrF,MAAM,KAAK,wEAAwE,GACnF,MAAM,KAAK,wEAAwE,GAGnF,MAAM,KACJ,6CAA6C,GAE/C,MAAM,KACJ,wBAAwB,UAAU,MAAM,SAAS,IAAI,CAAC,SAAS;AAGjE,UAAM,iBAAiB,QAAQ,UAAU,KAAK,iBACxC,aAAa,oBAAI,IAAG;AAG1B,eAAW,aAAa,gBAAgB;AACtC,YAAM,QAAQ,MAAM,MAAM,SAAS,SAAS;AAC5C,UAAK;AAEL,mBAAW,WAAW,MAAM,aAAY,GAAI;AAC1C,gBAAM,QAAQ,IAAI,aAAa,SAAS,KAAK,QAAQ;AAErD,gBAAM,KAAK,iBAAiB,QAAQ,EAAE,IAAI,GAC1C,MAAM,KAAK,0BAA0B,UAAU,QAAQ,IAAI,CAAC,SAAS,GACrE,MAAM,KAAK,gCAAgC,SAAS,SAAS,GAC7D,MAAM,KAAK,+BAA+B,QAAQ,IAAI,SAAS,GAE3D,QAAQ,eACV,MAAM,KACJ,sCAAsC,UAAU,QAAQ,WAAW,CAAC,SAAS,GAKjF,MAAM,KAAK,oDAAoD,KAAK,sBAAsB,GAC1F,MAAM,KAAK,uBAAuB,GAClC,MAAM,KAAK,uBAAuB,GAClC,MAAM,KAAK,0BAA0B,UAAU,QAAQ,IAAI,CAAC,gBAAgB,GAC5E,MAAM,KAAK,wBAAwB,GACnC,MAAM,KAAK,eAAe,GAE1B,MAAM,KAAK,aAAa,GAExB,WAAW,IAAI,QAAQ,IAAI;YACzB,OAAO;YACP,MAAM,QAAQ;YACd,aAAa,QAAQ;WACtB;QACH;IACF;AAGA,QAAI,cAAc;AAElB,eAAW,aAAa,gBAAgB;AACtC,YAAM,QAAQ,MAAM,MAAM,SAAS,SAAS;AAC5C,UAAK;AAEL,mBAAW,WAAW,MAAM,aAAY,GAAI;AAE1C,qBAAW,OAAO,QAAQ;AACxB,YAAK,WAAW,IAAI,IAAI,MAAM,MAI9B,MAAM,KACJ,kBAAkB,WAAW,aAAa,QAAQ,EAAE,aAAa,IAAI,MAAM,IAAI,GAEjF,MAAM,KAAK,+BAA+B,IAAI,IAAI,SAAS,GAC3D,MAAM,KAAK,0BAA0B,UAAU,IAAI,IAAI,CAAC,SAAS,GAE7D,IAAI,eACN,MAAM,KACJ,iCAAiC,UAAU,IAAI,WAAW,CAAC,SAAS,GAIxE,MAAM,KAAK,aAAa,GACxB;AAIF,qBAAW,OAAO,QAAQ;AACxB,YAAK,WAAW,IAAI,IAAI,MAAM,MAI9B,MAAM,KACJ,kBAAkB,WAAW,aAAa,QAAQ,EAAE,aAAa,IAAI,MAAM,IAAI,GAEjF,MAAM,KAAK,+BAA+B,IAAI,SAAS,SAAS,GAChE,MAAM,KAAK,0BAA0B,UAAU,IAAI,SAAS,CAAC,SAAS,GACtE,MAAM,KAAK,aAAa,GACxB;QAEJ;IACF;AAEA,iBAAM,KAAK,YAAY,GACvB,MAAM,KAAK,YAAY,GAEhB,MAAM,KAAK;CAAI;EACxB;;",
+  "names": []
+}

package/dist/export/index.js

@@ -0,0 +1,17 @@
+import { ExportManager } from "./export-manager.js";
+import { ArchiMateExporter } from "./archimate-exporter.js";
+import { OpenAPIExporter } from "./openapi-exporter.js";
+import { JsonSchemaExporter } from "./json-schema-exporter.js";
+import { PlantUMLExporter } from "./plantuml-exporter.js";
+import { GraphMLExporter } from "./graphml-exporter.js";
+import { MarkdownExporter } from "./markdown-exporter.js";
+export {
+  ArchiMateExporter,
+  ExportManager,
+  GraphMLExporter,
+  JsonSchemaExporter,
+  MarkdownExporter,
+  OpenAPIExporter,
+  PlantUMLExporter
+};
+//# sourceMappingURL=index.js.map

package/dist/export/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/export/index.ts"],
+  "sourcesContent": ["export { ExportManager } from \"./export-manager.js\";\nexport type { Exporter, ExportOptions, ExportFormatInfo } from \"./types.js\";\nexport { ArchiMateExporter } from \"./archimate-exporter.js\";\nexport { OpenAPIExporter } from \"./openapi-exporter.js\";\nexport { JsonSchemaExporter } from \"./json-schema-exporter.js\";\nexport { PlantUMLExporter } from \"./plantuml-exporter.js\";\nexport { GraphMLExporter } from \"./graphml-exporter.js\";\nexport { MarkdownExporter } from \"./markdown-exporter.js\";\n"],
+  "mappings": "AAAA,SAAS,qBAAqB;AAE9B,SAAS,yBAAyB;AAClC,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AACnC,SAAS,wBAAwB;AACjC,SAAS,uBAAuB;AAChC,SAAS,wBAAwB;",
+  "names": []
+}

package/dist/export/json-schema-exporter.js

@@ -0,0 +1,60 @@
+class JsonSchemaExporter {
+  name = "JSON Schema";
+  supportedLayers = ["data-model", "data_model"];
+  async export(model, _options = {}) {
+    let layer = await model.getLayer("data-model");
+    if (layer || (layer = await model.getLayer("data_model")), !layer)
+      throw new Error("No Data Model layer found in model");
+    const rootSchema = {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      $id: `${model.manifest.name.toLowerCase().replace(/\s+/g, "-")}-schema`,
+      title: model.manifest.name,
+      description: model.manifest.description || "Data model schema",
+      type: "object",
+      definitions: {}
+    };
+    for (const element of layer.listElements())
+      if (element.type === "entity") {
+        const entityName = element.name, properties = element.getProperty("properties"), required = element.getProperty("required"), description = element.description, entitySchema = {
+          title: entityName,
+          ...description && { description },
+          type: "object",
+          ...properties && { properties },
+          ...required && { required }
+        }, additionalProperties = element.getProperty("additionalProperties");
+        additionalProperties !== void 0 && (entitySchema.additionalProperties = additionalProperties);
+        const constraints = element.getProperty("constraints");
+        constraints && Object.assign(entitySchema, constraints), rootSchema.definitions[element.id] = entitySchema;
+      }
+    const relationships = {};
+    for (const element of layer.listElements())
+      if (element.type === "entity") {
+        for (const ref of element.references) {
+          const refKey = `${element.id}-references`;
+          relationships[refKey] || (relationships[refKey] = []), relationships[refKey].push({
+            target: ref.target,
+            type: ref.type
+          });
+        }
+        for (const rel of element.relationships) {
+          const relKey = `${element.id}-${rel.predicate}`;
+          relationships[relKey] || (relationships[relKey] = []), relationships[relKey].push({
+            target: rel.target
+          });
+        }
+      }
+    Object.keys(relationships).length > 0 && (rootSchema.relationships = relationships);
+    const metadata = {
+      version: model.manifest.version || "1.0.0",
+      ...model.manifest.author && { author: model.manifest.author },
+      ...model.manifest.created && { created: model.manifest.created },
+      ...model.manifest.modified && { modified: model.manifest.modified },
+      entityCount: Array.from(layer.listElements()).filter((e) => e.type === "entity").length
+    };
+    return rootSchema.metadata = metadata, JSON.stringify(rootSchema, null, 2);
+  }
+}
+export {
+  JsonSchemaExporter
+};
+//# sourceMappingURL=json-schema-exporter.js.map

package/dist/export/json-schema-exporter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/export/json-schema-exporter.ts"],
+  "sourcesContent": ["import type { Model } from \"../core/model.js\";\nimport type { Exporter, ExportOptions } from \"./types.js\";\n\n/**\n * JSON Schema Draft 7 Exporter for layer 7 (Data Model)\n */\nexport class JsonSchemaExporter implements Exporter {\n  name = \"JSON Schema\";\n  supportedLayers = [\"data-model\", \"data_model\"];\n\n  async export(model: Model, _options: ExportOptions = {}): Promise<string> {\n    // Try both naming conventions for data model layer\n    let layer = await model.getLayer(\"data-model\");\n    if (!layer) {\n      layer = await model.getLayer(\"data_model\");\n    }\n    if (!layer) {\n      throw new Error(\"No Data Model layer found in model\");\n    }\n\n    // Create a root schema that references all entities\n    const rootSchema: Record<string, unknown> = {\n      $schema: \"http://json-schema.org/draft-07/schema#\",\n      $id: `${model.manifest.name.toLowerCase().replace(/\\s+/g, \"-\")}-schema`,\n      title: model.manifest.name,\n      description: model.manifest.description || \"Data model schema\",\n      type: \"object\",\n      definitions: {},\n    };\n\n    // Process each entity in the data model layer\n    for (const element of layer.listElements()) {\n      if (element.type === \"entity\") {\n        const entityName = element.name;\n        const properties = element.getProperty<Record<string, unknown>>(\n          \"properties\"\n        );\n        const required = element.getProperty<string[]>(\"required\");\n        const description = element.description;\n\n        const entitySchema: Record<string, unknown> = {\n          title: entityName,\n          ...(description && { description }),\n          type: \"object\",\n          ...(properties && { properties }),\n          ...(required && { required }),\n        };\n\n        // Add additional metadata\n        const additionalProperties = element.getProperty<boolean>(\n          \"additionalProperties\"\n        );\n        if (additionalProperties !== undefined) {\n          entitySchema.additionalProperties = additionalProperties;\n        }\n\n        // Add constraints if present\n        const constraints = element.getProperty<Record<string, unknown>>(\n          \"constraints\"\n        );\n        if (constraints) {\n          Object.assign(entitySchema, constraints);\n        }\n\n        (rootSchema.definitions as Record<string, unknown>)[element.id] = entitySchema;\n      }\n    }\n\n    // Add relationships as references between entities\n    const relationships: Record<string, unknown> = {};\n    for (const element of layer.listElements()) {\n      if (element.type === \"entity\") {\n        for (const ref of element.references) {\n          // Cross-layer reference - document it\n          const refKey = `${element.id}-references`;\n          if (!relationships[refKey]) {\n            relationships[refKey] = [];\n          }\n          (relationships[refKey] as Array<{ target: string; type: string }>).push({\n            target: ref.target,\n            type: ref.type,\n          });\n        }\n\n        for (const rel of element.relationships) {\n          // Intra-layer relationship\n          const relKey = `${element.id}-${rel.predicate}`;\n          if (!relationships[relKey]) {\n            relationships[relKey] = [];\n          }\n          (relationships[relKey] as Array<{ target: string }>).push({\n            target: rel.target,\n          });\n        }\n      }\n    }\n\n    if (Object.keys(relationships).length > 0) {\n      rootSchema.relationships = relationships;\n    }\n\n    // Add metadata section\n    const metadata: Record<string, unknown> = {\n      version: model.manifest.version || \"1.0.0\",\n      ...(model.manifest.author && { author: model.manifest.author }),\n      ...(model.manifest.created && { created: model.manifest.created }),\n      ...(model.manifest.modified && { modified: model.manifest.modified }),\n      entityCount: Array.from(layer.listElements()).filter(\n        (e) => e.type === \"entity\"\n      ).length,\n    };\n    rootSchema.metadata = metadata;\n\n    return JSON.stringify(rootSchema, null, 2);\n  }\n}\n"],
+  "mappings": "AAMM,MAAO,mBAAkB;EAC7B,OAAO;EACP,kBAAkB,CAAC,cAAc,YAAY;EAE7C,MAAM,OAAO,OAAc,WAA0B,CAAA,GAAE;AAErD,QAAI,QAAQ,MAAM,MAAM,SAAS,YAAY;AAI7C,QAHK,UACH,QAAQ,MAAM,MAAM,SAAS,YAAY,IAEvC,CAAC;AACH,YAAM,IAAI,MAAM,oCAAoC;AAItD,UAAM,aAAsC;MAC1C,SAAS;MACT,KAAK,GAAG,MAAM,SAAS,KAAK,YAAW,EAAG,QAAQ,QAAQ,GAAG,CAAC;MAC9D,OAAO,MAAM,SAAS;MACtB,aAAa,MAAM,SAAS,eAAe;MAC3C,MAAM;MACN,aAAa,CAAA;;AAIf,eAAW,WAAW,MAAM,aAAY;AACtC,UAAI,QAAQ,SAAS,UAAU;AAC7B,cAAM,aAAa,QAAQ,MACrB,aAAa,QAAQ,YACzB,YAAY,GAER,WAAW,QAAQ,YAAsB,UAAU,GACnD,cAAc,QAAQ,aAEtB,eAAwC;UAC5C,OAAO;UACP,GAAI,eAAe,EAAE,YAAW;UAChC,MAAM;UACN,GAAI,cAAc,EAAE,WAAU;UAC9B,GAAI,YAAY,EAAE,SAAQ;WAItB,uBAAuB,QAAQ,YACnC,sBAAsB;AAExB,QAAI,yBAAyB,WAC3B,aAAa,uBAAuB;AAItC,cAAM,cAAc,QAAQ,YAC1B,aAAa;AAEf,QAAI,eACF,OAAO,OAAO,cAAc,WAAW,GAGxC,WAAW,YAAwC,QAAQ,EAAE,IAAI;MACpE;AAIF,UAAM,gBAAyC,CAAA;AAC/C,eAAW,WAAW,MAAM,aAAY;AACtC,UAAI,QAAQ,SAAS,UAAU;AAC7B,mBAAW,OAAO,QAAQ,YAAY;AAEpC,gBAAM,SAAS,GAAG,QAAQ,EAAE;AAC5B,UAAK,cAAc,MAAM,MACvB,cAAc,MAAM,IAAI,CAAA,IAEzB,cAAc,MAAM,EAA8C,KAAK;YACtE,QAAQ,IAAI;YACZ,MAAM,IAAI;WACX;QACH;AAEA,mBAAW,OAAO,QAAQ,eAAe;AAEvC,gBAAM,SAAS,GAAG,QAAQ,EAAE,IAAI,IAAI,SAAS;AAC7C,UAAK,cAAc,MAAM,MACvB,cAAc,MAAM,IAAI,CAAA,IAEzB,cAAc,MAAM,EAAgC,KAAK;YACxD,QAAQ,IAAI;WACb;QACH;MACF;AAGF,IAAI,OAAO,KAAK,aAAa,EAAE,SAAS,MACtC,WAAW,gBAAgB;AAI7B,UAAM,WAAoC;MACxC,SAAS,MAAM,SAAS,WAAW;MACnC,GAAI,MAAM,SAAS,UAAU,EAAE,QAAQ,MAAM,SAAS,OAAM;MAC5D,GAAI,MAAM,SAAS,WAAW,EAAE,SAAS,MAAM,SAAS,QAAO;MAC/D,GAAI,MAAM,SAAS,YAAY,EAAE,UAAU,MAAM,SAAS,SAAQ;MAClE,aAAa,MAAM,KAAK,MAAM,aAAY,CAAE,EAAE,OAC5C,CAAC,MAAM,EAAE,SAAS,QAAQ,EAC1B;;AAEJ,sBAAW,WAAW,UAEf,KAAK,UAAU,YAAY,MAAM,CAAC;EAC3C;;",
+  "names": []
+}

package/dist/export/markdown-exporter.js

@@ -0,0 +1,99 @@
+import { ALL_LAYERS } from "./types.js";
+class MarkdownExporter {
+  name = "Markdown";
+  supportedLayers = ALL_LAYERS;
+  layerDescriptions = {
+    motivation: "Goals, requirements, drivers, and strategic outcomes of the architecture.",
+    business: "Business processes, functions, roles, and services.",
+    security: "Authentication, authorization, security threats, and controls.",
+    application: "Application components, services, and interactions.",
+    technology: "Infrastructure, platforms, systems, and technology components.",
+    api: "REST APIs, operations, endpoints, and API integrations.",
+    "data-model": "Data entities, relationships, and data structure definitions.",
+    "data-store": "Databases, data stores, and persistence mechanisms.",
+    ux: "User interface components, screens, and user experience elements.",
+    navigation: "Application routing, navigation flows, and page structures.",
+    apm: "Observability, monitoring, metrics, logging, and tracing.",
+    testing: "Test strategies, test cases, test data, and test coverage."
+  };
+  async export(model, options = {}) {
+    const lines = [];
+    lines.push(`# ${this.escapeMarkdown(model.manifest.name)}`), lines.push(""), model.manifest.description && (lines.push(`${model.manifest.description}`), lines.push("")), lines.push("## Model Information"), lines.push(""), lines.push("| Property | Value |"), lines.push("| -------- | ----- |"), lines.push(`| Version | ${model.manifest.version || "1.0.0"} |`), model.manifest.author && lines.push(`| Author | ${this.escapeMarkdown(model.manifest.author)} |`), model.manifest.created && lines.push(`| Created | ${model.manifest.created} |`), model.manifest.modified && lines.push(`| Modified | ${model.manifest.modified} |`), lines.push("");
+    const layersToExport = options.layers || this.supportedLayers;
+    for (const layerName of layersToExport) {
+      const layer = await model.getLayer(layerName);
+      if (!layer)
+        continue;
+      const elements = Array.from(layer.listElements());
+      if (elements.length === 0)
+        continue;
+      lines.push(`## Layer: ${this.formatLayerName(layerName)}`), lines.push("");
+      const description = this.layerDescriptions[layerName];
+      description && (lines.push(`*${description}*`), lines.push("")), lines.push(`### Elements (${elements.length})`), lines.push(""), lines.push("| ID | Name | Type | Description |"), lines.push("| -- | ---- | ---- | ----------- |");
+      for (const element of elements) {
+        const id = this.escapeMarkdown(element.id), name = this.escapeMarkdown(element.name), type = this.escapeMarkdown(element.type), desc = element.description ? this.escapeMarkdown(element.description).substring(0, 100) : "";
+        lines.push(`| \`${id}\` | ${name} | ${type} | ${desc} |`);
+      }
+      lines.push(""), lines.push("### Element Details"), lines.push("");
+      for (const element of elements) {
+        if (lines.push(`#### ${this.escapeMarkdown(element.name)} (\`${element.id}\`)`), lines.push(""), element.description && (lines.push(`${element.description}`), lines.push("")), lines.push("**Type:** " + element.type), lines.push(""), Object.keys(element.properties).length > 0) {
+          lines.push("**Properties:**"), lines.push(""), lines.push("| Property | Value |"), lines.push("| -------- | ----- |");
+          for (const [key, value] of Object.entries(element.properties)) {
+            const displayValue = this.valueToMarkdown(value);
+            lines.push(`| \`${key}\` | ${displayValue} |`);
+          }
+          lines.push("");
+        }
+        if (element.references.length > 0) {
+          lines.push("**Cross-Layer References:**"), lines.push("");
+          for (const ref of element.references) {
+            const refDesc = ref.description ? ` - ${this.escapeMarkdown(ref.description)}` : "";
+            lines.push(`- **${ref.type}**: \`${ref.target}\`${refDesc}`);
+          }
+          lines.push("");
+        }
+        if (element.relationships.length > 0) {
+          lines.push("**Relationships:**"), lines.push("");
+          for (const rel of element.relationships)
+            lines.push(`- **${rel.predicate}**: \`${rel.target}\``);
+          lines.push("");
+        }
+      }
+      lines.push("### Layer Summary"), lines.push(""), lines.push(`- **Total Elements:** ${elements.length}`);
+      const refCount = elements.reduce((sum, e) => sum + e.references.length, 0), relCount = elements.reduce((sum, e) => sum + e.relationships.length, 0);
+      lines.push(`- **Cross-Layer References:** ${refCount}`), lines.push(`- **Relationships:** ${relCount}`), lines.push(""), lines.push("---"), lines.push("");
+    }
+    lines.push("## Architecture Summary"), lines.push("");
+    let totalElements = 0, totalReferences = 0, totalRelationships = 0;
+    for (const layerName of layersToExport) {
+      const layer = await model.getLayer(layerName);
+      if (layer)
+        for (const element of layer.listElements())
+          totalElements++, totalReferences += element.references.length, totalRelationships += element.relationships.length;
+    }
+    return lines.push("| Metric | Count |"), lines.push("| ------ | ----- |"), lines.push(`| Total Elements | ${totalElements} |`), lines.push(`| Cross-Layer References | ${totalReferences} |`), lines.push(`| Relationships | ${totalRelationships} |`), lines.push(""), lines.join(`
+`);
+  }
+  /**
+   * Escape markdown special characters
+   */
+  escapeMarkdown(str) {
+    return str.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\*/g, "\\*").replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/\{/g, "\\{").replace(/\}/g, "\\}");
+  }
+  /**
+   * Format layer name for display
+   */
+  formatLayerName(name) {
+    return name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+  /**
+   * Convert value to markdown representation
+   */
+  valueToMarkdown(value) {
+    return typeof value == "string" ? this.escapeMarkdown(value) : typeof value == "number" || typeof value == "boolean" ? String(value) : Array.isArray(value) ? `[${value.map((v) => this.valueToMarkdown(v)).join(", ")}]` : value && typeof value == "object" ? `\`${this.escapeMarkdown(JSON.stringify(value))}\`` : String(value);
+  }
+}
+export {
+  MarkdownExporter
+};
+//# sourceMappingURL=markdown-exporter.js.map