@documentation-robotics/cli 0.1.0 → 0.1.7

package/dist/core/relationship-catalog.js

@@ -0,0 +1,189 @@
+import path from "node:path";
+import { fileURLToPath } from "url";
+import fs from "node:fs/promises";
+import { glob } from "glob";
+import { getErrorMessage } from "../utils/errors.js";
+class RelationshipCatalog {
+  predicatesData = null;
+  relationshipTypes = null;
+  predicatesPath;
+  relationshipSchemasPath;
+  constructor(predicatesPath, relationshipSchemasPath) {
+    this.predicatesPath = predicatesPath || this.getDefaultPredicatesPath(), this.relationshipSchemasPath = relationshipSchemasPath || this.getDefaultRelationshipSchemasPath();
+  }
+  /**
+   * Get default path to base.json (contains predicates under .predicates key)
+   */
+  getDefaultPredicatesPath() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    return path.join(currentDir, "../schemas/bundled/base.json");
+  }
+  /**
+   * Get default path to bundled schemas directory (contains manifest.json + per-layer JSON files)
+   */
+  getDefaultRelationshipSchemasPath() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    return path.join(currentDir, "../schemas/bundled");
+  }
+  /**
+   * Load predicates and compute derived metadata
+   */
+  async load() {
+    try {
+      const content = await fs.readFile(this.predicatesPath, "utf-8"), parsed = JSON.parse(content);
+      this.predicatesData = parsed.predicates !== void 0 ? { predicates: parsed.predicates } : parsed;
+    } catch (error) {
+      try {
+        const fallbackPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "../../../spec/schemas/base/predicates.json"), content = await fs.readFile(fallbackPath, "utf-8");
+        this.predicatesData = JSON.parse(content), this.predicatesPath = fallbackPath, console.debug(`Loaded predicates from fallback path: ${fallbackPath}`);
+      } catch {
+        throw new Error(`Failed to load predicates from ${this.predicatesPath}: ${getErrorMessage(error)}`);
+      }
+    }
+    const applicableLayersByPredicate = await this.computeApplicableLayers();
+    this.relationshipTypes = Object.entries(this.predicatesData.predicates).map(([key, pred]) => ({
+      id: key,
+      predicate: pred.predicate,
+      inversePredicate: pred.inverse,
+      category: pred.category,
+      archimateAlignment: pred.archimate_alignment,
+      description: pred.description,
+      semantics: pred.semantics,
+      applicableLayers: applicableLayersByPredicate[pred.predicate] || [],
+      examples: []
+      // Examples are documentation, not stored in predicates
+    }));
+  }
+  /**
+   * Compute which layers each predicate is used in by reading compiled layer dist files
+   */
+  async computeApplicableLayers() {
+    const layersByPredicate = {};
+    try {
+      const manifestPath = path.join(this.relationshipSchemasPath, "manifest.json");
+      await fs.access(manifestPath);
+      const manifestContent = await fs.readFile(manifestPath, "utf-8"), manifest = JSON.parse(manifestContent);
+      for (const { id: layerId } of manifest.layers) {
+        const layerPath = path.join(this.relationshipSchemasPath, `${layerId}.json`);
+        try {
+          await fs.access(layerPath);
+          const layerContent = await fs.readFile(layerPath, "utf-8"), layerData = JSON.parse(layerContent);
+          for (const relSchema of Object.values(layerData.relationshipSchemas || {})) {
+            const { predicate, source_layer } = relSchema;
+            predicate && source_layer && (layersByPredicate[predicate] || (layersByPredicate[predicate] = /* @__PURE__ */ new Set()), layersByPredicate[predicate].add(source_layer));
+          }
+        } catch {
+        }
+      }
+    } catch {
+      const fallbackPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "../../../spec/schemas/relationships");
+      try {
+        await fs.access(fallbackPath);
+        const relationshipFiles = await glob(`${fallbackPath}/**/*.relationship.schema.json`);
+        for (const file of relationshipFiles)
+          try {
+            const content = await fs.readFile(file, "utf-8"), schema = JSON.parse(content), predicate = schema.properties?.predicate?.const, sourceLayer = schema.properties?.source_layer?.const;
+            predicate && sourceLayer && (layersByPredicate[predicate] || (layersByPredicate[predicate] = /* @__PURE__ */ new Set()), layersByPredicate[predicate].add(sourceLayer));
+          } catch {
+            continue;
+          }
+      } catch {
+        return {};
+      }
+    }
+    const result = {};
+    for (const [predicate, layers] of Object.entries(layersByPredicate))
+      result[predicate] = Array.from(layers).sort();
+    return result;
+  }
+  /**
+   * Ensure catalog is loaded
+   */
+  ensureLoaded() {
+    if (!this.relationshipTypes)
+      throw new Error("Relationship catalog not loaded. Call load() first.");
+  }
+  /**
+   * Get all relationship types
+   */
+  getAllTypes() {
+    return this.ensureLoaded(), this.relationshipTypes;
+  }
+  /**
+   * Get relationship type by ID
+   */
+  getTypeById(id) {
+    return this.ensureLoaded(), this.relationshipTypes.find((t) => t.id === id);
+  }
+  /**
+   * Get relationship type by predicate
+   */
+  getTypeByPredicate(predicate) {
+    return this.ensureLoaded(), this.relationshipTypes.find((t) => t.predicate === predicate || t.inversePredicate === predicate);
+  }
+  /**
+   * Get relationship types by category
+   */
+  getTypesByCategory(category) {
+    return this.ensureLoaded(), this.relationshipTypes.filter((t) => t.category === category);
+  }
+  /**
+   * Get relationship types applicable to a layer
+   */
+  getTypesForLayer(layer) {
+    this.ensureLoaded();
+    const normalizedLayer = layer.replace(/^0+/, "");
+    return this.relationshipTypes.filter((t) => t.applicableLayers.some((l) => l === layer || l === normalizedLayer || l.replace(/^0+/, "") === normalizedLayer));
+  }
+  /**
+   * Get all categories
+   */
+  getCategories() {
+    this.ensureLoaded();
+    const categories = {}, categoryCounts = {};
+    for (const type of this.relationshipTypes)
+      categoryCounts[type.category] || (categoryCounts[type.category] = 0, categories[type.category] = {
+        name: type.category.charAt(0).toUpperCase() + type.category.slice(1),
+        description: `${type.category} relationships`
+      }), categoryCounts[type.category]++;
+    return categories;
+  }
+  /**
+   * Get statistics about the catalog
+   */
+  getStats() {
+    this.ensureLoaded();
+    const categoryCounts = {};
+    let archimateAligned = 0;
+    for (const type of this.relationshipTypes)
+      categoryCounts[type.category] = (categoryCounts[type.category] || 0) + 1, type.archimateAlignment && archimateAligned++;
+    return {
+      totalTypes: this.relationshipTypes.length,
+      categoryCounts,
+      archimateAligned
+    };
+  }
+  /**
+   * Get catalog metadata
+   */
+  getMetadata() {
+    return this.ensureLoaded(), {
+      version: "1.0.0",
+      generatedBy: "relationship-catalog (predicates.json)",
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      totalTypes: this.relationshipTypes.length
+    };
+  }
+  /**
+   * Search relationship types by keyword
+   */
+  search(keyword) {
+    this.ensureLoaded();
+    const lowerKeyword = keyword.toLowerCase();
+    return this.relationshipTypes.filter((t) => t.id.toLowerCase().includes(lowerKeyword) || t.predicate.toLowerCase().includes(lowerKeyword) || t.inversePredicate && t.inversePredicate.toLowerCase().includes(lowerKeyword) || t.description.toLowerCase().includes(lowerKeyword) || t.category.toLowerCase().includes(lowerKeyword));
+  }
+}
+export {
+  RelationshipCatalog
+};
+//# sourceMappingURL=relationship-catalog.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/relationship-catalog.ts"],
+  "sourcesContent": ["/**\n * Relationship Catalog - Manages catalog of semantic relationship types\n *\n * Loads predicates from spec/schemas/base/predicates.json and computes\n * derived metadata (applicableLayers) by scanning relationship schemas.\n */\n\nimport path from \"node:path\";\nimport { fileURLToPath } from \"url\";\nimport fs from \"node:fs/promises\";\nimport { glob } from \"glob\";\nimport { getErrorMessage } from \"../utils/errors.js\";\n\n/**\n * Directionality of a relationship\n */\nexport type Directionality = \"unidirectional\" | \"bidirectional\";\n\nexport interface RelationshipSemantics {\n  directionality: Directionality;\n  transitivity: boolean;\n  symmetry: boolean;\n  reflexivity?: boolean;\n}\n\nexport interface RelationshipExample {\n  source: string;\n  target: string;\n  description: string;\n  layer?: string;\n}\n\nexport interface RelationshipType {\n  id: string;\n  predicate: string;\n  inversePredicate: string | null;\n  category: string;\n  archimateAlignment: string | null;\n  description: string;\n  semantics: RelationshipSemantics;\n  applicableLayers: string[];  // Computed from relationship schemas\n  examples: RelationshipExample[];  // Empty for now\n}\n\nexport interface PredicateDefinition {\n  predicate: string;\n  inverse: string;\n  category: string;\n  description: string;\n  archimate_alignment: string | null;\n  semantics: RelationshipSemantics;\n}\n\nexport interface PredicatesData {\n  predicates: Record<string, PredicateDefinition>;\n}\n\nexport interface CategoryInfo {\n  name: string;\n  description: string;\n  color?: string;\n}\n\n/**\n * Relationship catalog providing access to semantic relationship type definitions\n */\nexport class RelationshipCatalog {\n  private predicatesData: PredicatesData | null = null;\n  private relationshipTypes: RelationshipType[] | null = null;\n  private predicatesPath: string;\n  private relationshipSchemasPath: string;\n\n  constructor(predicatesPath?: string, relationshipSchemasPath?: string) {\n    this.predicatesPath = predicatesPath || this.getDefaultPredicatesPath();\n    this.relationshipSchemasPath = relationshipSchemasPath || this.getDefaultRelationshipSchemasPath();\n  }\n\n  /**\n   * Get default path to base.json (contains predicates under .predicates key)\n   */\n  private getDefaultPredicatesPath(): string {\n    const currentDir = path.dirname(fileURLToPath(import.meta.url));\n    return path.join(currentDir, \"../schemas/bundled/base.json\");\n  }\n\n  /**\n   * Get default path to bundled schemas directory (contains manifest.json + per-layer JSON files)\n   */\n  private getDefaultRelationshipSchemasPath(): string {\n    const currentDir = path.dirname(fileURLToPath(import.meta.url));\n    return path.join(currentDir, \"../schemas/bundled\");\n  }\n\n  /**\n   * Load predicates and compute derived metadata\n   */\n  async load(): Promise<void> {\n    // Load predicates \u2014 supports both base.json format (has .predicates key) and direct predicates.json\n    try {\n      const content = await fs.readFile(this.predicatesPath, \"utf-8\");\n      const parsed = JSON.parse(content);\n      // base.json has { specVersion, schemas, predicates } \u2014 extract .predicates key\n      // predicates.json has { predicates } directly\n      // In both cases, .predicates is the dict of PredicateDefinition objects\n      this.predicatesData = parsed.predicates !== undefined\n        ? { predicates: parsed.predicates }\n        : parsed;\n    } catch (error) {\n      // Try fallback path (direct predicates.json in spec source tree)\n      try {\n        const fallbackPath = path.join(\n          path.dirname(fileURLToPath(import.meta.url)),\n          \"../../../spec/schemas/base/predicates.json\"\n        );\n        const content = await fs.readFile(fallbackPath, \"utf-8\");\n        this.predicatesData = JSON.parse(content);\n        this.predicatesPath = fallbackPath;\n        console.debug(`Loaded predicates from fallback path: ${fallbackPath}`);\n      } catch {\n        throw new Error(\n          `Failed to load predicates from ${this.predicatesPath}: ${getErrorMessage(error)}`\n        );\n      }\n    }\n\n    // Compute applicableLayers by scanning relationship schemas\n    const applicableLayersByPredicate = await this.computeApplicableLayers();\n\n    // Convert predicates to RelationshipType format\n    this.relationshipTypes = Object.entries(this.predicatesData!.predicates).map(([key, pred]) => ({\n      id: key,\n      predicate: pred.predicate,\n      inversePredicate: pred.inverse,\n      category: pred.category,\n      archimateAlignment: pred.archimate_alignment,\n      description: pred.description,\n      semantics: pred.semantics,\n      applicableLayers: applicableLayersByPredicate[pred.predicate] || [],\n      examples: [],  // Examples are documentation, not stored in predicates\n    }));\n  }\n\n  /**\n   * Compute which layers each predicate is used in by reading compiled layer dist files\n   */\n  private async computeApplicableLayers(): Promise<Record<string, string[]>> {\n    const layersByPredicate: Record<string, Set<string>> = {};\n\n    try {\n      // Try compiled bundled format (manifest.json + per-layer JSON files)\n      const manifestPath = path.join(this.relationshipSchemasPath, \"manifest.json\");\n      await fs.access(manifestPath);\n\n      const manifestContent = await fs.readFile(manifestPath, \"utf-8\");\n      const manifest = JSON.parse(manifestContent) as { layers: Array<{ id: string }> };\n\n      for (const { id: layerId } of manifest.layers) {\n        const layerPath = path.join(this.relationshipSchemasPath, `${layerId}.json`);\n        try {\n          await fs.access(layerPath);\n          const layerContent = await fs.readFile(layerPath, \"utf-8\");\n          const layerData = JSON.parse(layerContent) as {\n            relationshipSchemas: Record<string, { predicate: string; source_layer: string }>;\n          };\n\n          for (const relSchema of Object.values(layerData.relationshipSchemas || {})) {\n            const { predicate, source_layer } = relSchema;\n            if (predicate && source_layer) {\n              if (!layersByPredicate[predicate]) {\n                layersByPredicate[predicate] = new Set();\n              }\n              layersByPredicate[predicate].add(source_layer);\n            }\n          }\n        } catch {\n          // Skip missing or malformed layer files\n        }\n      }\n    } catch {\n      // Fall back to spec source tree (development environment)\n      const fallbackPath = path.join(\n        path.dirname(fileURLToPath(import.meta.url)),\n        \"../../../spec/schemas/relationships\"\n      );\n      try {\n        await fs.access(fallbackPath);\n        const relationshipFiles = await glob(`${fallbackPath}/**/*.relationship.schema.json`);\n\n        for (const file of relationshipFiles) {\n          try {\n            const content = await fs.readFile(file, \"utf-8\");\n            const schema = JSON.parse(content);\n            const predicate = schema.properties?.predicate?.const;\n            const sourceLayer = schema.properties?.source_layer?.const;\n\n            if (predicate && sourceLayer) {\n              if (!layersByPredicate[predicate]) {\n                layersByPredicate[predicate] = new Set();\n              }\n              layersByPredicate[predicate].add(sourceLayer);\n            }\n          } catch {\n            continue;\n          }\n        }\n      } catch {\n        // No relationship schemas found, return empty\n        return {};\n      }\n    }\n\n    // Convert Sets to sorted arrays\n    const result: Record<string, string[]> = {};\n    for (const [predicate, layers] of Object.entries(layersByPredicate)) {\n      result[predicate] = Array.from(layers).sort();\n    }\n\n    return result;\n  }\n\n  /**\n   * Ensure catalog is loaded\n   */\n  private ensureLoaded(): void {\n    if (!this.relationshipTypes) {\n      throw new Error(\"Relationship catalog not loaded. Call load() first.\");\n    }\n  }\n\n  /**\n   * Get all relationship types\n   */\n  getAllTypes(): RelationshipType[] {\n    this.ensureLoaded();\n    return this.relationshipTypes!;\n  }\n\n  /**\n   * Get relationship type by ID\n   */\n  getTypeById(id: string): RelationshipType | undefined {\n    this.ensureLoaded();\n    return this.relationshipTypes!.find((t) => t.id === id);\n  }\n\n  /**\n   * Get relationship type by predicate\n   */\n  getTypeByPredicate(predicate: string): RelationshipType | undefined {\n    this.ensureLoaded();\n    return this.relationshipTypes!.find(\n      (t) => t.predicate === predicate || t.inversePredicate === predicate\n    );\n  }\n\n  /**\n   * Get relationship types by category\n   */\n  getTypesByCategory(category: string): RelationshipType[] {\n    this.ensureLoaded();\n    return this.relationshipTypes!.filter((t) => t.category === category);\n  }\n\n  /**\n   * Get relationship types applicable to a layer\n   */\n  getTypesForLayer(layer: string): RelationshipType[] {\n    this.ensureLoaded();\n    // Normalize layer format (remove leading zeros if present)\n    const normalizedLayer = layer.replace(/^0+/, \"\");\n\n    return this.relationshipTypes!.filter((t) =>\n      t.applicableLayers.some(\n        (l) => l === layer || l === normalizedLayer || l.replace(/^0+/, \"\") === normalizedLayer\n      )\n    );\n  }\n\n  /**\n   * Get all categories\n   */\n  getCategories(): Record<string, CategoryInfo> {\n    this.ensureLoaded();\n\n    // Derive categories from relationship types\n    const categories: Record<string, CategoryInfo> = {};\n    const categoryCounts: Record<string, number> = {};\n\n    for (const type of this.relationshipTypes!) {\n      if (!categoryCounts[type.category]) {\n        categoryCounts[type.category] = 0;\n        categories[type.category] = {\n          name: type.category.charAt(0).toUpperCase() + type.category.slice(1),\n          description: `${type.category} relationships`,\n        };\n      }\n      categoryCounts[type.category]++;\n    }\n\n    return categories;\n  }\n\n  /**\n   * Get statistics about the catalog\n   */\n  getStats(): {\n    totalTypes: number;\n    categoryCounts: Record<string, number>;\n    archimateAligned: number;\n  } {\n    this.ensureLoaded();\n\n    const categoryCounts: Record<string, number> = {};\n    let archimateAligned = 0;\n\n    for (const type of this.relationshipTypes!) {\n      categoryCounts[type.category] = (categoryCounts[type.category] || 0) + 1;\n      if (type.archimateAlignment) {\n        archimateAligned++;\n      }\n    }\n\n    return {\n      totalTypes: this.relationshipTypes!.length,\n      categoryCounts,\n      archimateAligned,\n    };\n  }\n\n  /**\n   * Get catalog metadata\n   */\n  getMetadata(): {\n    version: string;\n    generatedBy: string;\n    lastUpdated: string;\n    totalTypes: number;\n  } {\n    this.ensureLoaded();\n    return {\n      version: \"1.0.0\",\n      generatedBy: \"relationship-catalog (predicates.json)\",\n      lastUpdated: new Date().toISOString(),\n      totalTypes: this.relationshipTypes!.length,\n    };\n  }\n\n  /**\n   * Search relationship types by keyword\n   */\n  search(keyword: string): RelationshipType[] {\n    this.ensureLoaded();\n    const lowerKeyword = keyword.toLowerCase();\n\n    return this.relationshipTypes!.filter(\n      (t) =>\n        t.id.toLowerCase().includes(lowerKeyword) ||\n        t.predicate.toLowerCase().includes(lowerKeyword) ||\n        (t.inversePredicate && t.inversePredicate.toLowerCase().includes(lowerKeyword)) ||\n        t.description.toLowerCase().includes(lowerKeyword) ||\n        t.category.toLowerCase().includes(lowerKeyword)\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -1,7 +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;;",
+  "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 and cross-layer relationships and their catalog\n *\n * NOTE: Future consolidation - Registry to GraphModel API\n * This registry will be consolidated into the GraphModel query API in a future refactoring.\n * The graph model provides the foundation for relationship tracking via edges.\n * Current approach maintains backward compatibility while the transition occurs.\n *\n * Future approach: Use GraphModel.getEdgesFrom/To with predicate filtering,\n * supporting both intra-layer (source_layer === destination_layer) and\n * cross-layer (source_layer !== destination_layer) relationships per the spec.\n *\n * See: https://github.com/tinkermonkey/documentation_robotics/discussions/317\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((rel) => rel.target === targetId && rel.predicate === predicate);\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) => !type.applicable_layers || type.applicable_layers.includes(layerPrefix))\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": "AA4BM,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,CAAC,QAAQ,IAAI,cAAc,SAAS,CAAC;AAEnE,WAAO;EACT;;;;EAKA,gBAAgB,UAAkB,UAAkB,WAAiB;AAEnE,YADa,KAAK,cAAc,IAAI,QAAQ,KAAK,CAAA,GACrC,KAAK,CAAC,QAAQ,IAAI,WAAW,YAAY,IAAI,cAAc,SAAS;EAClF;;;;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,CAAC,SAAS,CAAC,KAAK,qBAAqB,KAAK,kBAAkB,SAAS,WAAW,CAAC,EACxF,IAAI,CAAC,SAAS,KAAK,SAAS;EACjC;;;;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.map

@@ -1,7 +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"],
+  "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/core/report-data-model.js

@@ -0,0 +1,285 @@
+import { StatsCollector } from "./stats-collector.js";
+import { RelationshipCatalog } from "./relationship-catalog.js";
+import { getLayerOrder } from "./layers.js";
+function createClassifiedRelationship(rel, sourceLayer, targetLayer) {
+  return {
+    ...rel,
+    sourceLayer,
+    targetLayer,
+    isCrossLayer: sourceLayer !== targetLayer
+  };
+}
+class ReportDataModel {
+  model;
+  statsCollector;
+  relationshipCatalog;
+  cachedStats = null;
+  cachedRelationships = null;
+  cachedDataModel = null;
+  cachedQuality = null;
+  cachedReport = null;
+  relationshipTypeMap = /* @__PURE__ */ new Map();
+  catalogLoaded = !1;
+  constructor(model) {
+    this.model = model, this.statsCollector = new StatsCollector(model), this.relationshipCatalog = new RelationshipCatalog();
+  }
+  /**
+   * Load the relationship catalog and build relationship type map
+   */
+  async loadCatalog() {
+    if (this.catalogLoaded)
+      return;
+    await this.relationshipCatalog.load();
+    const types = this.relationshipCatalog.getAllTypes();
+    for (const type of types)
+      this.relationshipTypeMap.set(type.predicate, type);
+    this.catalogLoaded = !0;
+  }
+  /**
+   * Collect all report data (statistics, relationships, data model, quality metrics)
+   */
+  async collect() {
+    if (this.cachedReport)
+      return this.cachedReport;
+    try {
+      await this.loadCatalog();
+      const statistics = await this.getStatistics(), relationships = await this.getRelationshipAnalysis(), dataModel = await this.getDataModelInsights(), quality = await this.getQualityMetrics();
+      return this.cachedReport = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        statistics,
+        relationships,
+        dataModel,
+        quality
+      }, this.cachedReport;
+    } catch (error) {
+      throw new Error(`Failed to collect report data: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+  }
+  /**
+   * Get model statistics
+   */
+  async getStatistics() {
+    return this.cachedStats ? this.cachedStats : (this.cachedStats = await this.statsCollector.collect(), this.cachedStats);
+  }
+  /**
+   * Get relationship analysis with classification
+   */
+  async getRelationshipAnalysis() {
+    if (this.cachedRelationships)
+      return this.cachedRelationships;
+    await this.loadCatalog();
+    const allRelationships = this.model.relationships.getAll(), classified = [], byCategory = {}, byPredicate = {};
+    let crossLayerCount = 0, intraLayerCount = 0;
+    for (let i = 0; i < allRelationships.length; i++) {
+      const rel = allRelationships[i], relationshipId = `${rel.source}\u2192${rel.predicate}\u2192${rel.target}`, classifiedRel = this.classifyRelationship(rel, relationshipId);
+      classified.push(classifiedRel), byCategory[classifiedRel.category] || (byCategory[classifiedRel.category] = 0), byCategory[classifiedRel.category]++, byPredicate[rel.predicate] || (byPredicate[rel.predicate] = 0), byPredicate[rel.predicate]++, classifiedRel.isCrossLayer ? crossLayerCount++ : intraLayerCount++;
+    }
+    const circularDependencies = this.detectCircularDependencies(classified);
+    return this.cachedRelationships = {
+      totalRelationships: allRelationships.length,
+      classified,
+      byCategory,
+      byPredicate,
+      crossLayerCount,
+      intraLayerCount,
+      circularDependencies
+    }, this.cachedRelationships;
+  }
+  /**
+   * Get relationships filtered by category
+   */
+  async getRelationshipsByCategory(category) {
+    return (await this.getRelationshipAnalysis()).classified.filter((rel) => rel.category === category);
+  }
+  /**
+   * Get data model layer (Layer 7) specific insights
+   */
+  async getDataModelInsights() {
+    if (this.cachedDataModel)
+      return this.cachedDataModel;
+    const dataModelLayer = await this.model.getLayer("data-model"), entities = [];
+    let attributeCount = 0;
+    if (dataModelLayer) {
+      const elements = dataModelLayer.listElements(), referencesFrom = /* @__PURE__ */ new Set();
+      for (const layerName of this.model.getLayerNames()) {
+        if (layerName === "data-model")
+          continue;
+        const layer = await this.model.getLayer(layerName);
+        if (layer) {
+          for (const element of layer.listElements())
+            if (element.references)
+              for (const ref of element.references)
+                ref.target.startsWith("data-model.") && referencesFrom.add(ref.target);
+        }
+      }
+      for (const element of elements) {
+        const attributes = element.attributes ? Object.keys(element.attributes) : [];
+        attributeCount += attributes.length, entities.push({
+          id: element.path || element.id || "",
+          name: element.name,
+          layer: "data-model",
+          attributes,
+          relatedEntities: element.relationships ? element.relationships.map((r) => r.target) : [],
+          isReferenced: referencesFrom.has(element.path || element.id || "")
+        });
+      }
+    }
+    const entityCount = entities.length, referencedCount = entities.filter((e) => e.isReferenced).length, orphaned = entities.filter((e) => !e.isReferenced && e.relatedEntities.length === 0), entitiesWithAttributes = entities.filter((e) => e.attributes.length > 0).length, attributeCoverage = entityCount > 0 ? entitiesWithAttributes / entityCount * 100 : 0, avgAttrs = entityCount > 0 ? attributeCount / entityCount : 0, maxAttrs = Math.max(0, ...entities.map((e) => e.attributes.length)), avgRels = entityCount > 0 ? entities.reduce((sum, e) => sum + e.relatedEntities.length, 0) / entityCount : 0;
+    return this.cachedDataModel = {
+      entityCount,
+      attributeCount,
+      relationshipCount: entities.reduce((sum, e) => sum + e.relatedEntities.length, 0),
+      entities,
+      entityCoverage: entityCount > 0 ? referencedCount / entityCount * 100 : 0,
+      attributeCoverage,
+      avgAttributesPerEntity: Math.round(avgAttrs * 10) / 10,
+      maxAttributesPerEntity: maxAttrs,
+      avgRelationshipsPerEntity: Math.round(avgRels * 10) / 10,
+      referencedEntities: referencedCount,
+      orphanedEntities: orphaned.map((e) => e.id)
+    }, this.cachedDataModel;
+  }
+  /**
+   * Get quality metrics for the model
+   */
+  async getQualityMetrics() {
+    if (this.cachedQuality)
+      return this.cachedQuality;
+    const stats = await this.getStatistics(), relationships = await this.getRelationshipAnalysis(), elementCoverage = stats.statistics.totalElements > 0 ? 100 : 0, relationshipCoverage = stats.statistics.totalElements > 0 ? stats.statistics.totalRelationships / stats.statistics.totalElements * 100 : 0, documentationCoverage = this.calculateDocumentationCoverage(stats), layerCoverage = stats.statistics.totalLayers > 0 ? stats.statistics.populatedLayers / stats.statistics.totalLayers * 100 : 0, orphanedElements = stats.orphanedElements.length, circularDependencies = relationships.circularDependencies.length, archimateCompliance = this.calculateArchimateCompliance(relationships), specCompliance = this.calculateSpecCompliance(relationships), semanticConsistency = (archimateCompliance + specCompliance) / 2, crossLayerReferenceHealth = relationships.totalRelationships > 0 ? relationships.crossLayerCount / relationships.totalRelationships * 100 : 0, layerComplianceScore = this.calculateLayerComplianceScore(relationships);
+    return this.cachedQuality = {
+      elementCoverage,
+      relationshipCoverage: Math.min(100, relationshipCoverage),
+      documentationCoverage: Math.min(100, documentationCoverage),
+      layerCoverage: Math.min(100, layerCoverage),
+      orphanedElements,
+      circularDependencies,
+      archimateCompliance,
+      specCompliance,
+      semanticConsistency,
+      crossLayerReferenceHealth: Math.min(100, crossLayerReferenceHealth),
+      layerComplianceScore
+    }, this.cachedQuality;
+  }
+  /**
+   * Classify a single relationship with semantic metadata
+   */
+  classifyRelationship(rel, id) {
+    const sourceParts = rel.source.split("."), targetParts = rel.target.split("."), sourceLayer = sourceParts[0], targetLayer = targetParts[0];
+    (!sourceLayer || !targetLayer) && console.warn(`[REPORT_001] Malformed element ID format in relationship: source="${rel.source}" (${sourceParts.length} parts), target="${rel.target}" (${targetParts.length} parts). Expected format: layer.type.name`);
+    const relationshipType = this.relationshipTypeMap.get(rel.predicate), isSpecCompliant = relationshipType !== void 0;
+    return createClassifiedRelationship({
+      id,
+      source: rel.source,
+      target: rel.target,
+      predicate: rel.predicate,
+      category: relationshipType?.category || "unknown",
+      archimateAlignment: relationshipType?.archimateAlignment || null,
+      directionality: relationshipType?.semantics?.directionality || "unidirectional",
+      transitivity: relationshipType?.semantics?.transitivity || !1,
+      symmetry: relationshipType?.semantics?.symmetry || !1,
+      reflexivity: relationshipType?.semantics?.reflexivity,
+      isSpecCompliant
+    }, sourceLayer, targetLayer);
+  }
+  /**
+   * Detect circular dependencies in relationships
+   * Max depth limit prevents stack overflow on complex graphs
+   */
+  detectCircularDependencies(relationships) {
+    const circularPaths = [], visited = /* @__PURE__ */ new Set(), path = [], predicatePath = [];
+    for (const rel of relationships)
+      visited.has(rel.source) || this.findCircles(rel.source, relationships, visited, path, predicatePath, circularPaths, 0, 100);
+    return circularPaths;
+  }
+  /**
+   * Helper to find circular paths using DFS with depth limit
+   */
+  findCircles(node, relationships, visited, path, predicatePath, circularPaths, depth, maxDepth) {
+    if (!(depth > maxDepth)) {
+      if (path.includes(node)) {
+        const circleStart = path.indexOf(node), circlePath = path.slice(circleStart), circlePredicates = predicatePath.slice(circleStart), circleKey = [...circlePath].sort().join("\u2192");
+        !circularPaths.some((c) => [...c.elements].sort().join("\u2192") === circleKey) && circlePath.length > 1 && circularPaths.push({
+          elements: circlePath,
+          predicates: circlePredicates,
+          pathLength: circlePath.length
+        });
+        return;
+      }
+      if (!visited.has(node)) {
+        path.push(node), visited.add(node);
+        for (const rel of relationships)
+          rel.source === node && (predicatePath.push(rel.predicate), this.findCircles(rel.target, relationships, visited, path, predicatePath, circularPaths, depth + 1, maxDepth), predicatePath.pop());
+        path.pop(), visited.delete(node);
+      }
+    }
+  }
+  /**
+   * Calculate documentation coverage percentage
+   * Checks what proportion of elements have meaningful descriptions
+   */
+  calculateDocumentationCoverage(stats) {
+    if (stats.statistics.totalElements === 0)
+      return 0;
+    let documentedCount = 0;
+    for (const layerName of this.model.getLayerNames()) {
+      const layer = this.model.layers.get(layerName);
+      if (layer)
+        for (const element of layer.listElements())
+          element.description && element.description.trim().length > 0 && documentedCount++;
+    }
+    return Math.round(documentedCount / stats.statistics.totalElements * 100);
+  }
+  /**
+   * Calculate ArchiMate alignment percentage
+   */
+  calculateArchimateCompliance(analysis) {
+    if (analysis.totalRelationships === 0)
+      return 100;
+    const archimateAligned = analysis.classified.filter((r) => r.archimateAlignment).length;
+    return Math.round(archimateAligned / analysis.totalRelationships * 100);
+  }
+  /**
+   * Calculate spec compliance percentage
+   */
+  calculateSpecCompliance(analysis) {
+    if (analysis.totalRelationships === 0)
+      return 100;
+    const specCompliant = analysis.classified.filter((r) => r.isSpecCompliant).length;
+    return Math.round(specCompliant / analysis.totalRelationships * 100);
+  }
+  /**
+   * Calculate layer compliance score (directional compliance)
+   * Measures adherence to the higher -> lower layer reference rule
+   */
+  calculateLayerComplianceScore(analysis) {
+    const validRelationships = analysis.classified.filter((rel) => {
+      const sourceOrder = getLayerOrder(rel.sourceLayer), targetOrder = getLayerOrder(rel.targetLayer);
+      return sourceOrder > 0 && targetOrder > 0;
+    });
+    if (validRelationships.length === 0)
+      return 100;
+    let compliantCount = 0;
+    for (const rel of validRelationships) {
+      const sourceOrder = getLayerOrder(rel.sourceLayer), targetOrder = getLayerOrder(rel.targetLayer);
+      sourceOrder >= targetOrder && compliantCount++;
+    }
+    return Math.round(compliantCount / validRelationships.length * 100);
+  }
+  /**
+   * Clear all cached data
+   */
+  clearCache() {
+    this.cachedStats = null, this.cachedRelationships = null, this.cachedDataModel = null, this.cachedQuality = null, this.cachedReport = null;
+  }
+  /**
+   * Get the relationship catalog
+   */
+  getCatalog() {
+    return this.relationshipCatalog;
+  }
+}
+export {
+  ReportDataModel,
+  createClassifiedRelationship
+};
+//# sourceMappingURL=report-data-model.js.map