@documentation-robotics/cli 0.1.0 → 0.1.5

package/dist/audit/relationships/graph/relationship-graph.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/graph/relationship-graph.ts"],
+  "sourcesContent": ["/**\n * Relationship Graph - Graph analysis wrapper for audit system\n *\n * Builds directed graphs from intra-layer relationships using GraphModel\n * and provides audit-specific graph queries.\n */\n\nimport { GraphModel, type GraphEdge } from \"../../../core/graph-model.js\";\nimport { RELATIONSHIPS } from \"../../../generated/relationship-index.js\";\nimport { getAllLayers } from \"../../../generated/layer-registry.js\";\nimport type { Relationship } from \"../../../core/relationships.js\";\nimport type { Element } from \"../../../core/element.js\";\n\n/**\n * Relationship graph for audit analysis\n */\nexport class RelationshipGraph {\n  private graph: GraphModel;\n\n  constructor() {\n    this.graph = new GraphModel();\n  }\n\n  /**\n   * Build graph from intra-layer relationships\n   */\n  async build(layerId?: string): Promise<void> {\n    this.graph.clear();\n\n    // Filter relationships by layer if specified\n    const relationships = layerId\n      ? RELATIONSHIPS.filter((r) =>\n          r.sourceSpecNodeId.startsWith(`${layerId}.`)\n        )\n      : RELATIONSHIPS;\n\n    // Add nodes (node types as graph nodes)\n    const nodeTypes = new Set<string>();\n\n    // First, collect nodes from relationships\n    for (const rel of relationships) {\n      nodeTypes.add(rel.sourceSpecNodeId);\n      nodeTypes.add(rel.destinationSpecNodeId);\n    }\n\n    // If building a layer-specific graph, also add all node types from that layer\n    // (even if they have no relationships)\n    if (layerId) {\n      const layers = getAllLayers();\n      const layer = layers.find((l) => l.id === layerId);\n      if (layer) {\n        for (const nodeType of layer.nodeTypes) {\n          nodeTypes.add(nodeType);\n        }\n      }\n    }\n\n    for (const nodeType of nodeTypes) {\n      const [layer, type] = nodeType.split(\".\");\n      this.graph.addNode({\n        id: nodeType,\n        layer: layer || \"unknown\",\n        type: type || \"unknown\",\n        name: nodeType,\n        properties: {},\n      });\n    }\n\n    // Add edges (relationships as graph edges)\n    const skippedEdges: Array<{\n      relationshipId: string;\n      source: string;\n      destination: string;\n      reason: string;\n    }> = [];\n\n    for (const rel of relationships) {\n      try {\n        this.graph.addEdge({\n          id: rel.id,\n          source: rel.sourceSpecNodeId,\n          destination: rel.destinationSpecNodeId,\n          predicate: rel.predicate,\n          properties: {\n            cardinality: rel.cardinality,\n            strength: rel.strength,\n            required: rel.required,\n          },\n        });\n      } catch (error) {\n        // Track data integrity issues - relationships referencing non-existent node types\n        const reason = error instanceof Error ? error.message : String(error);\n        skippedEdges.push({\n          relationshipId: rel.id,\n          source: rel.sourceSpecNodeId,\n          destination: rel.destinationSpecNodeId,\n          reason,\n        });\n\n        // Log to stderr for visibility\n        console.error(\n          `\u26A0\uFE0F  Data integrity issue: Relationship \"${rel.id}\" references non-existent node type. ${reason}`\n        );\n      }\n    }\n\n    // Report summary if any edges were skipped\n    if (skippedEdges.length > 0) {\n      console.error(\n        `\\n\u26A0\uFE0F  Warning: ${skippedEdges.length} relationship(s) skipped due to missing node type references.`\n      );\n      console.error(\n        `This indicates data integrity issues in the relationship schemas.`\n      );\n      console.error(\n        `Run 'dr schema relationships' to validate relationship definitions.\\n`\n      );\n    }\n  }\n\n  /**\n   * Get node count\n   */\n  getNodeCount(): number {\n    return this.graph.getNodeCount();\n  }\n\n  /**\n   * Get edge count\n   */\n  getEdgeCount(): number {\n    return this.graph.getEdgeCount();\n  }\n\n  /**\n   * Get all node types in the graph\n   */\n  getNodeTypes(): string[] {\n    return Array.from(this.graph.nodes.keys());\n  }\n\n  /**\n   * Get outgoing relationships for a node type\n   */\n  getOutgoingRelationships(nodeType: string): GraphEdge[] {\n    return this.graph.getEdgesFrom(nodeType);\n  }\n\n  /**\n   * Get incoming relationships for a node type\n   */\n  getIncomingRelationships(nodeType: string): GraphEdge[] {\n    return this.graph.getEdgesTo(nodeType);\n  }\n\n  /**\n   * Get all relationships for a node type\n   */\n  getAllRelationships(nodeType: string): GraphEdge[] {\n    return [\n      ...this.graph.getEdgesFrom(nodeType),\n      ...this.graph.getEdgesTo(nodeType),\n    ];\n  }\n\n  /**\n   * Find paths between two node types\n   */\n  findPaths(\n    sourceType: string,\n    destType: string,\n    maxDepth: number = 5\n  ): string[][] {\n    const paths: string[][] = [];\n    const visited = new Set<string>();\n\n    const dfs = (current: string, path: string[], depth: number) => {\n      if (depth > maxDepth) {\n        return;\n      }\n\n      if (current === destType) {\n        paths.push([...path, current]);\n        return;\n      }\n\n      if (visited.has(current)) {\n        return;\n      }\n\n      visited.add(current);\n      path.push(current);\n\n      const outgoing = this.graph.getEdgesFrom(current);\n      for (const edge of outgoing) {\n        dfs(edge.destination, [...path], depth + 1);\n      }\n\n      visited.delete(current);\n    };\n\n    dfs(sourceType, [], 0);\n    return paths;\n  }\n\n  /**\n   * Get neighbors of a node type\n   */\n  getNeighbors(nodeType: string): string[] {\n    const neighbors = new Set<string>();\n\n    const outgoing = this.graph.getEdgesFrom(nodeType);\n    for (const edge of outgoing) {\n      neighbors.add(edge.destination);\n    }\n\n    const incoming = this.graph.getEdgesTo(nodeType);\n    for (const edge of incoming) {\n      neighbors.add(edge.source);\n    }\n\n    return Array.from(neighbors);\n  }\n\n  /**\n   * Get the underlying graph model\n   */\n  getGraphModel(): GraphModel {\n    return this.graph;\n  }\n\n  /**\n   * Build graph from actual model relationship instances and elements.\n   * Used by ModelAuditOrchestrator to analyse the project model rather than spec schemas.\n   */\n  buildFromModel(relationships: Relationship[], elements: Element[]): void {\n    this.graph.clear();\n\n    // Index elements by both UUID id and path/slug \u2014 relationships store slug paths.\n    const elementById = new Map<string, Element>();\n    for (const e of elements) {\n      elementById.set(e.id, e);\n      if (e.path && e.path !== e.id) elementById.set(e.path, e);\n    }\n\n    // Add one graph node per distinct spec_node_id (using spec_node_id as the node id)\n    const specNodeIds = new Set<string>(\n      elements.map((e) => e.spec_node_id).filter(Boolean)\n    );\n\n    for (const specNodeId of specNodeIds) {\n      const [layer, type] = specNodeId.split(\".\");\n      this.graph.addNode({\n        id: specNodeId,\n        layer: layer ?? \"unknown\",\n        type: type ?? \"unknown\",\n        name: specNodeId,\n        properties: {},\n      });\n    }\n\n    // Add edges from relationship instances, keyed by source/target spec_node_id\n    let edgeCounter = 0;\n    for (const rel of relationships) {\n      const srcEl = elementById.get(rel.source);\n      const dstEl = elementById.get(rel.target);\n      if (!srcEl?.spec_node_id || !dstEl?.spec_node_id) continue;\n\n      try {\n        this.graph.addEdge({\n          id: `model-rel-${edgeCounter++}`,\n          source: srcEl.spec_node_id,\n          destination: dstEl.spec_node_id,\n          predicate: rel.predicate,\n          properties: rel.properties as Record<string, unknown> | undefined,\n          category: rel.category,\n        });\n      } catch {\n        // Silently skip edges where the node wasn't added (shouldn't happen but be safe)\n      }\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/audit/relationships/model/balance-assessor.js

@@ -0,0 +1,49 @@
+const DENSITY_TARGETS = {
+  structural: [2, 4],
+  behavioral: [3, 5],
+  enumeration: [1, 2],
+  reference: [0, 1]
+};
+function assessLayerBalance(layerId, elements, intraLayerRels) {
+  const assessments = [], elementById = /* @__PURE__ */ new Map();
+  for (const e of elements)
+    elementById.set(e.id, e), e.path && e.path !== e.id && elementById.set(e.path, e);
+  const relCountBySpecNodeId = /* @__PURE__ */ new Map();
+  for (const rel of intraLayerRels) {
+    const srcEl = elementById.get(rel.source);
+    srcEl?.spec_node_id && relCountBySpecNodeId.set(srcEl.spec_node_id, (relCountBySpecNodeId.get(srcEl.spec_node_id) ?? 0) + 1);
+  }
+  const specNodeIds = new Set(elements.map((e) => e.spec_node_id).filter(Boolean));
+  for (const specNodeId of specNodeIds) {
+    const category = classifyNodeType(specNodeId), currentCount = relCountBySpecNodeId.get(specNodeId) ?? 0, targetRange = DENSITY_TARGETS[category], [min, max] = targetRange, status = currentCount < min ? "under" : currentCount > max ? "over" : "balanced", recommendation = buildRecommendation(specNodeId, category, currentCount, targetRange, status);
+    assessments.push({
+      nodeType: specNodeId,
+      layer: layerId,
+      category,
+      currentCount,
+      targetRange,
+      status,
+      recommendation
+    });
+  }
+  return assessments;
+}
+function classifyNodeType(specNodeId) {
+  const type = specNodeId.split(".")[1] ?? "";
+  return type.endsWith("level") || type.endsWith("type") || type.endsWith("status") || type.endsWith("priority") || type.endsWith("scope") || type.endsWith("action") || type.endsWith("category") || type.endsWith("format") ? "enumeration" : type.includes("component") || type.includes("container") || type.includes("service") || type.includes("module") || type.includes("collaboration") || type.includes("interface") || type.includes("device") || type.includes("node") || type.includes("artifact") ? "structural" : type.includes("process") || type.includes("operation") || type.includes("event") || type.includes("flow") || type.includes("interaction") || type.includes("function") || type.includes("trigger") ? "behavioral" : "reference";
+}
+function buildRecommendation(specNodeId, category, currentCount, targetRange, status) {
+  const [min, max] = targetRange, typeName = specNodeId.split(".").pop() ?? specNodeId;
+  if (status === "under") {
+    const needed = min - currentCount;
+    return `Add ${needed} relationship instance${needed > 1 ? "s" : ""} for ${typeName} (${category} type) to reach minimum target`;
+  }
+  if (status === "over") {
+    const excess = currentCount - max;
+    return `Consider removing ${excess} relationship instance${excess > 1 ? "s" : ""} from ${typeName} or reviewing ${category} type classification`;
+  }
+}
+export {
+  assessLayerBalance
+};
+//# sourceMappingURL=balance-assessor.js.map

package/dist/audit/relationships/model/balance-assessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/model/balance-assessor.ts"],
+  "sourcesContent": ["/**\n * Model Balance Assessor - Assesses relationship density balance in model instances\n *\n * Groups relationship instances by source element's spec_node_id and applies\n * the same target-range logic as the spec-based BalanceAssessor.\n */\n\nimport type { Relationship } from \"../../../core/relationships.js\";\nimport type { Element } from \"../../../core/element.js\";\nimport type { BalanceAssessment } from \"../../types.js\";\n\n/**\n * Density targets for different node type categories (matches BalanceAssessor)\n */\nconst DENSITY_TARGETS: Record<string, [number, number]> = {\n  structural: [2, 4],\n  behavioral: [3, 5],\n  enumeration: [1, 2],\n  reference: [0, 1],\n};\n\n/**\n * Assess balance for a layer using model instances\n */\nexport function assessLayerBalance(\n  layerId: string,\n  elements: Element[],\n  intraLayerRels: Relationship[]\n): BalanceAssessment[] {\n  const assessments: BalanceAssessment[] = [];\n\n  // Build count of outgoing intra-layer rels per spec_node_id.\n  // Index by both UUID id and path/slug \u2014 relationships store slug paths.\n  const elementById = new Map<string, Element>();\n  for (const e of elements) {\n    elementById.set(e.id, e);\n    if (e.path && e.path !== e.id) elementById.set(e.path, e);\n  }\n\n  const relCountBySpecNodeId = new Map<string, number>();\n  for (const rel of intraLayerRels) {\n    const srcEl = elementById.get(rel.source);\n    if (!srcEl?.spec_node_id) continue;\n    relCountBySpecNodeId.set(\n      srcEl.spec_node_id,\n      (relCountBySpecNodeId.get(srcEl.spec_node_id) ?? 0) + 1\n    );\n  }\n\n  // Assess each distinct spec_node_id present in this layer\n  const specNodeIds = new Set<string>(\n    elements.map((e) => e.spec_node_id).filter(Boolean)\n  );\n\n  for (const specNodeId of specNodeIds) {\n    const category = classifyNodeType(specNodeId);\n    const currentCount = relCountBySpecNodeId.get(specNodeId) ?? 0;\n    const targetRange = DENSITY_TARGETS[category];\n    const [min, max] = targetRange;\n    const status: \"under\" | \"balanced\" | \"over\" =\n      currentCount < min ? \"under\" : currentCount > max ? \"over\" : \"balanced\";\n    const recommendation = buildRecommendation(\n      specNodeId,\n      category,\n      currentCount,\n      targetRange,\n      status\n    );\n\n    assessments.push({\n      nodeType: specNodeId,\n      layer: layerId,\n      category,\n      currentCount,\n      targetRange,\n      status,\n      recommendation,\n    });\n  }\n\n  return assessments;\n}\n\nfunction classifyNodeType(\n  specNodeId: string\n): \"structural\" | \"behavioral\" | \"enumeration\" | \"reference\" {\n  const type = specNodeId.split(\".\")[1] ?? \"\";\n\n  if (\n    type.endsWith(\"level\") ||\n    type.endsWith(\"type\") ||\n    type.endsWith(\"status\") ||\n    type.endsWith(\"priority\") ||\n    type.endsWith(\"scope\") ||\n    type.endsWith(\"action\") ||\n    type.endsWith(\"category\") ||\n    type.endsWith(\"format\")\n  ) {\n    return \"enumeration\";\n  }\n\n  if (\n    type.includes(\"component\") ||\n    type.includes(\"container\") ||\n    type.includes(\"service\") ||\n    type.includes(\"module\") ||\n    type.includes(\"collaboration\") ||\n    type.includes(\"interface\") ||\n    type.includes(\"device\") ||\n    type.includes(\"node\") ||\n    type.includes(\"artifact\")\n  ) {\n    return \"structural\";\n  }\n\n  if (\n    type.includes(\"process\") ||\n    type.includes(\"operation\") ||\n    type.includes(\"event\") ||\n    type.includes(\"flow\") ||\n    type.includes(\"interaction\") ||\n    type.includes(\"function\") ||\n    type.includes(\"trigger\")\n  ) {\n    return \"behavioral\";\n  }\n\n  return \"reference\";\n}\n\nfunction buildRecommendation(\n  specNodeId: string,\n  category: string,\n  currentCount: number,\n  targetRange: [number, number],\n  status: \"under\" | \"balanced\" | \"over\"\n): string | undefined {\n  const [min, max] = targetRange;\n  const typeName = specNodeId.split(\".\").pop() ?? specNodeId;\n\n  if (status === \"under\") {\n    const needed = min - currentCount;\n    return `Add ${needed} relationship instance${needed > 1 ? \"s\" : \"\"} for ${typeName} (${category} type) to reach minimum target`;\n  }\n  if (status === \"over\") {\n    const excess = currentCount - max;\n    return `Consider removing ${excess} relationship instance${excess > 1 ? \"s\" : \"\"} from ${typeName} or reviewing ${category} type classification`;\n  }\n  return undefined;\n}\n"],
+  "mappings": "AAcA,MAAM,kBAAoD;EACxD,YAAY,CAAC,GAAG,CAAC;EACjB,YAAY,CAAC,GAAG,CAAC;EACjB,aAAa,CAAC,GAAG,CAAC;EAClB,WAAW,CAAC,GAAG,CAAC;;AAMZ,SAAU,mBACd,SACA,UACA,gBAA8B;AAE9B,QAAM,cAAmC,CAAA,GAInC,cAAc,oBAAI,IAAG;AAC3B,aAAW,KAAK;AACd,gBAAY,IAAI,EAAE,IAAI,CAAC,GACnB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAI,YAAY,IAAI,EAAE,MAAM,CAAC;AAG1D,QAAM,uBAAuB,oBAAI,IAAG;AACpC,aAAW,OAAO,gBAAgB;AAChC,UAAM,QAAQ,YAAY,IAAI,IAAI,MAAM;AACxC,IAAK,OAAO,gBACZ,qBAAqB,IACnB,MAAM,eACL,qBAAqB,IAAI,MAAM,YAAY,KAAK,KAAK,CAAC;EAE3D;AAGA,QAAM,cAAc,IAAI,IACtB,SAAS,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,OAAO,CAAC;AAGrD,aAAW,cAAc,aAAa;AACpC,UAAM,WAAW,iBAAiB,UAAU,GACtC,eAAe,qBAAqB,IAAI,UAAU,KAAK,GACvD,cAAc,gBAAgB,QAAQ,GACtC,CAAC,KAAK,GAAG,IAAI,aACb,SACJ,eAAe,MAAM,UAAU,eAAe,MAAM,SAAS,YACzD,iBAAiB,oBACrB,YACA,UACA,cACA,aACA,MAAM;AAGR,gBAAY,KAAK;MACf,UAAU;MACV,OAAO;MACP;MACA;MACA;MACA;MACA;KACD;EACH;AAEA,SAAO;AACT;AAEA,SAAS,iBACP,YAAkB;AAElB,QAAM,OAAO,WAAW,MAAM,GAAG,EAAE,CAAC,KAAK;AAEzC,SACE,KAAK,SAAS,OAAO,KACrB,KAAK,SAAS,MAAM,KACpB,KAAK,SAAS,QAAQ,KACtB,KAAK,SAAS,UAAU,KACxB,KAAK,SAAS,OAAO,KACrB,KAAK,SAAS,QAAQ,KACtB,KAAK,SAAS,UAAU,KACxB,KAAK,SAAS,QAAQ,IAEf,gBAIP,KAAK,SAAS,WAAW,KACzB,KAAK,SAAS,WAAW,KACzB,KAAK,SAAS,SAAS,KACvB,KAAK,SAAS,QAAQ,KACtB,KAAK,SAAS,eAAe,KAC7B,KAAK,SAAS,WAAW,KACzB,KAAK,SAAS,QAAQ,KACtB,KAAK,SAAS,MAAM,KACpB,KAAK,SAAS,UAAU,IAEjB,eAIP,KAAK,SAAS,SAAS,KACvB,KAAK,SAAS,WAAW,KACzB,KAAK,SAAS,OAAO,KACrB,KAAK,SAAS,MAAM,KACpB,KAAK,SAAS,aAAa,KAC3B,KAAK,SAAS,UAAU,KACxB,KAAK,SAAS,SAAS,IAEhB,eAGF;AACT;AAEA,SAAS,oBACP,YACA,UACA,cACA,aACA,QAAqC;AAErC,QAAM,CAAC,KAAK,GAAG,IAAI,aACb,WAAW,WAAW,MAAM,GAAG,EAAE,IAAG,KAAM;AAEhD,MAAI,WAAW,SAAS;AACtB,UAAM,SAAS,MAAM;AACrB,WAAO,OAAO,MAAM,yBAAyB,SAAS,IAAI,MAAM,EAAE,QAAQ,QAAQ,KAAK,QAAQ;EACjG;AACA,MAAI,WAAW,QAAQ;AACrB,UAAM,SAAS,eAAe;AAC9B,WAAO,qBAAqB,MAAM,yBAAyB,SAAS,IAAI,MAAM,EAAE,SAAS,QAAQ,iBAAiB,QAAQ;EAC5H;AAEF;",
+  "names": []
+}

package/dist/audit/relationships/model/coverage-analyzer.js

@@ -0,0 +1,34 @@
+import { createPercentage } from "../../types.js";
+function analyzeLayerCoverage(layerId, elements, intraLayerRels, interLayerRels, catalog) {
+  const specNodeIds = new Set(elements.map((e) => e.spec_node_id).filter(Boolean)), nodeTypeCount = specNodeIds.size, elementById = /* @__PURE__ */ new Map();
+  for (const e of elements)
+    elementById.set(e.id, e), e.path && e.path !== e.id && elementById.set(e.path, e);
+  const relCountBySpecNodeId = /* @__PURE__ */ new Map(), usedPredicatesSet = /* @__PURE__ */ new Set();
+  for (const rel of intraLayerRels) {
+    const sourceEl = elementById.get(rel.source);
+    sourceEl?.spec_node_id && relCountBySpecNodeId.set(sourceEl.spec_node_id, (relCountBySpecNodeId.get(sourceEl.spec_node_id) ?? 0) + 1), usedPredicatesSet.add(rel.predicate);
+  }
+  for (const rel of interLayerRels) {
+    const sourceEl = elementById.get(rel.source);
+    sourceEl?.spec_node_id && relCountBySpecNodeId.set(sourceEl.spec_node_id, (relCountBySpecNodeId.get(sourceEl.spec_node_id) ?? 0) + 1);
+    const targetEl = elementById.get(rel.target);
+    targetEl?.spec_node_id && relCountBySpecNodeId.set(targetEl.spec_node_id, (relCountBySpecNodeId.get(targetEl.spec_node_id) ?? 0) + 1), usedPredicatesSet.add(rel.predicate);
+  }
+  const relationshipCount = intraLayerRels.length, interLayerRelationshipCount = interLayerRels.length, isolatedNodeTypes = Array.from(specNodeIds).filter((id) => (relCountBySpecNodeId.get(id) ?? 0) === 0), isolationPercentage = createPercentage(nodeTypeCount > 0 ? isolatedNodeTypes.length / nodeTypeCount * 100 : 0), availablePredicates = catalog.getTypesForLayer(layerId).map((t) => t.predicate), availablePredicateSet = new Set(availablePredicates), usedPredicates = Array.from(usedPredicatesSet).filter((p) => availablePredicateSet.has(p)), utilizationPercentage = createPercentage(availablePredicates.length > 0 ? usedPredicates.length / availablePredicates.length * 100 : 0), relationshipsPerNodeType = nodeTypeCount > 0 ? relationshipCount / nodeTypeCount : 0;
+  return {
+    layer: layerId,
+    nodeTypeCount,
+    relationshipCount,
+    interLayerRelationshipCount,
+    isolatedNodeTypes,
+    isolationPercentage,
+    availablePredicates,
+    usedPredicates,
+    utilizationPercentage,
+    relationshipsPerNodeType
+  };
+}
+export {
+  analyzeLayerCoverage
+};
+//# sourceMappingURL=coverage-analyzer.js.map

package/dist/audit/relationships/model/coverage-analyzer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/model/coverage-analyzer.ts"],
+  "sourcesContent": ["/**\n * Model Coverage Analyzer - Coverage metrics from actual model relationship instances\n */\n\nimport type { Relationship } from \"../../../core/relationships.js\";\nimport type { Element } from \"../../../core/element.js\";\nimport { RelationshipCatalog } from \"../../../core/relationship-catalog.js\";\nimport type { CoverageMetrics } from \"../../types.js\";\nimport { createPercentage } from \"../../types.js\";\n\n/**\n * Analyze relationship coverage for a single layer using model instances\n */\nexport function analyzeLayerCoverage(\n  layerId: string,\n  elements: Element[],\n  intraLayerRels: Relationship[],\n  interLayerRels: Relationship[],\n  catalog: RelationshipCatalog\n): CoverageMetrics {\n  // Distinct spec_node_ids present in this layer\n  const specNodeIds = new Set<string>(\n    elements.map((e) => e.spec_node_id).filter(Boolean)\n  );\n  const nodeTypeCount = specNodeIds.size;\n\n  // Index elements by both UUID id and path/slug \u2014 relationships store slug paths.\n  const elementById = new Map<string, Element>();\n  for (const e of elements) {\n    elementById.set(e.id, e);\n    if (e.path && e.path !== e.id) elementById.set(e.path, e);\n  }\n\n  // Count relationship instances per spec_node_id \u2014 includes both intra and inter-layer\n  // relationships for isolation scoring. A node type is only isolated if it participates\n  // in no relationships at all (not just intra-layer ones).\n  const relCountBySpecNodeId = new Map<string, number>();\n  const usedPredicatesSet = new Set<string>();\n\n  for (const rel of intraLayerRels) {\n    const sourceEl = elementById.get(rel.source);\n    if (sourceEl?.spec_node_id) {\n      relCountBySpecNodeId.set(\n        sourceEl.spec_node_id,\n        (relCountBySpecNodeId.get(sourceEl.spec_node_id) ?? 0) + 1\n      );\n    }\n    usedPredicatesSet.add(rel.predicate);\n  }\n\n  // Cross-layer relationships count toward isolation and predicate utilization.\n  // Without this, node types that only participate in cross-layer relationships\n  // appear isolated and their predicates don't appear in usedPredicates.\n  for (const rel of interLayerRels) {\n    const sourceEl = elementById.get(rel.source);\n    if (sourceEl?.spec_node_id) {\n      relCountBySpecNodeId.set(\n        sourceEl.spec_node_id,\n        (relCountBySpecNodeId.get(sourceEl.spec_node_id) ?? 0) + 1\n      );\n    }\n    // Also count inbound rels \u2014 a node type targeted by a cross-layer relationship\n    // is not isolated, even if it never acts as a source.\n    const targetEl = elementById.get(rel.target);\n    if (targetEl?.spec_node_id) {\n      relCountBySpecNodeId.set(\n        targetEl.spec_node_id,\n        (relCountBySpecNodeId.get(targetEl.spec_node_id) ?? 0) + 1\n      );\n    }\n    usedPredicatesSet.add(rel.predicate);\n  }\n\n  const relationshipCount = intraLayerRels.length;\n  const interLayerRelationshipCount = interLayerRels.length;\n\n  // Isolated: spec_node_ids present in layer with zero relationship instances (intra OR inter)\n  const isolatedNodeTypes = Array.from(specNodeIds).filter(\n    (id) => (relCountBySpecNodeId.get(id) ?? 0) === 0\n  );\n  const isolationPercentage = createPercentage(\n    nodeTypeCount > 0 ? (isolatedNodeTypes.length / nodeTypeCount) * 100 : 0\n  );\n\n  // Available predicates for this layer from catalog\n  const availablePredicates = catalog\n    .getTypesForLayer(layerId)\n    .map((t) => t.predicate);\n  const availablePredicateSet = new Set(availablePredicates);\n\n  // Only count predicates that the catalog defines for this layer\n  const usedPredicates = Array.from(usedPredicatesSet).filter((p) =>\n    availablePredicateSet.has(p)\n  );\n\n  const utilizationPercentage = createPercentage(\n    availablePredicates.length > 0\n      ? (usedPredicates.length / availablePredicates.length) * 100\n      : 0\n  );\n\n  const relationshipsPerNodeType =\n    nodeTypeCount > 0 ? relationshipCount / nodeTypeCount : 0;\n\n  return {\n    layer: layerId,\n    nodeTypeCount,\n    relationshipCount,\n    interLayerRelationshipCount,\n    isolatedNodeTypes,\n    isolationPercentage,\n    availablePredicates,\n    usedPredicates,\n    utilizationPercentage,\n    relationshipsPerNodeType,\n  };\n}\n"],
+  "mappings": "AAQA,SAAS,wBAAwB;AAK3B,SAAU,qBACd,SACA,UACA,gBACA,gBACA,SAA4B;AAG5B,QAAM,cAAc,IAAI,IACtB,SAAS,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,OAAO,CAAC,GAE/C,gBAAgB,YAAY,MAG5B,cAAc,oBAAI,IAAG;AAC3B,aAAW,KAAK;AACd,gBAAY,IAAI,EAAE,IAAI,CAAC,GACnB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAI,YAAY,IAAI,EAAE,MAAM,CAAC;AAM1D,QAAM,uBAAuB,oBAAI,IAAG,GAC9B,oBAAoB,oBAAI,IAAG;AAEjC,aAAW,OAAO,gBAAgB;AAChC,UAAM,WAAW,YAAY,IAAI,IAAI,MAAM;AAC3C,IAAI,UAAU,gBACZ,qBAAqB,IACnB,SAAS,eACR,qBAAqB,IAAI,SAAS,YAAY,KAAK,KAAK,CAAC,GAG9D,kBAAkB,IAAI,IAAI,SAAS;EACrC;AAKA,aAAW,OAAO,gBAAgB;AAChC,UAAM,WAAW,YAAY,IAAI,IAAI,MAAM;AAC3C,IAAI,UAAU,gBACZ,qBAAqB,IACnB,SAAS,eACR,qBAAqB,IAAI,SAAS,YAAY,KAAK,KAAK,CAAC;AAK9D,UAAM,WAAW,YAAY,IAAI,IAAI,MAAM;AAC3C,IAAI,UAAU,gBACZ,qBAAqB,IACnB,SAAS,eACR,qBAAqB,IAAI,SAAS,YAAY,KAAK,KAAK,CAAC,GAG9D,kBAAkB,IAAI,IAAI,SAAS;EACrC;AAEA,QAAM,oBAAoB,eAAe,QACnC,8BAA8B,eAAe,QAG7C,oBAAoB,MAAM,KAAK,WAAW,EAAE,OAChD,CAAC,QAAQ,qBAAqB,IAAI,EAAE,KAAK,OAAO,CAAC,GAE7C,sBAAsB,iBAC1B,gBAAgB,IAAK,kBAAkB,SAAS,gBAAiB,MAAM,CAAC,GAIpE,sBAAsB,QACzB,iBAAiB,OAAO,EACxB,IAAI,CAAC,MAAM,EAAE,SAAS,GACnB,wBAAwB,IAAI,IAAI,mBAAmB,GAGnD,iBAAiB,MAAM,KAAK,iBAAiB,EAAE,OAAO,CAAC,MAC3D,sBAAsB,IAAI,CAAC,CAAC,GAGxB,wBAAwB,iBAC5B,oBAAoB,SAAS,IACxB,eAAe,SAAS,oBAAoB,SAAU,MACvD,CAAC,GAGD,2BACJ,gBAAgB,IAAI,oBAAoB,gBAAgB;AAE1D,SAAO;IACL,OAAO;IACP;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;;AAEJ;",
+  "names": []
+}

package/dist/audit/relationships/model/duplicate-detector.js

@@ -0,0 +1,68 @@
+import { duplicateImpactScore } from "../../types.js";
+import { isValidRelationship } from "../../../generated/relationship-index.js";
+function detectModelDuplicates(relationships, elements, catalog) {
+  const candidates = [], elementById = /* @__PURE__ */ new Map();
+  for (const e of elements)
+    elementById.set(e.id, e), e.path && e.path !== e.id && elementById.set(e.path, e);
+  const exactGroups = /* @__PURE__ */ new Map();
+  for (const rel of relationships) {
+    const key = `${rel.source}|${rel.predicate}|${rel.target}`, group = exactGroups.get(key) ?? [];
+    group.push(rel), exactGroups.set(key, group);
+  }
+  for (const [compositeKey, group] of exactGroups) {
+    if (group.length < 2)
+      continue;
+    const rel = group[0], srcEl = elementById.get(rel.source), dstEl = elementById.get(rel.target), exactImpactScore = duplicateImpactScore("high");
+    candidates.push({
+      relationships: [compositeKey, compositeKey],
+      predicates: [rel.predicate, rel.predicate],
+      sourceNodeType: srcEl?.spec_node_id ?? rel.source,
+      destinationNodeType: dstEl?.spec_node_id ?? rel.target,
+      reason: `Exact duplicate: (${rel.source}, ${rel.predicate}, ${rel.target}) appears ${group.length} times`,
+      confidence: "high",
+      impactScore: exactImpactScore,
+      alignmentScore: 100 - exactImpactScore
+    });
+  }
+  const semanticGroups = /* @__PURE__ */ new Map();
+  for (const rel of relationships) {
+    const srcEl = elementById.get(rel.source), dstEl = elementById.get(rel.target);
+    if (!srcEl?.spec_node_id || !dstEl?.spec_node_id)
+      continue;
+    const key = `${rel.source}|${rel.target}`, group = semanticGroups.get(key) ?? [];
+    group.push({ predicate: rel.predicate, sourceId: rel.source, targetId: rel.target, sourceSpecNodeId: srcEl.spec_node_id, destSpecNodeId: dstEl.spec_node_id }), semanticGroups.set(key, group);
+  }
+  for (const [_key, group] of semanticGroups) {
+    if (group.length < 2)
+      continue;
+    const sourceSpecNodeId = group[0].sourceSpecNodeId, destSpecNodeId = group[0].destSpecNodeId;
+    for (let i = 0; i < group.length; i++)
+      for (let j = i + 1; j < group.length; j++) {
+        const p1 = group[i].predicate, p2 = group[j].predicate;
+        if (p1 === p2)
+          continue;
+        const type1 = catalog.getTypeByPredicate(p1), type2 = catalog.getTypeByPredicate(p2);
+        if (!type1 || !type2 || type1.category !== type2.category || isValidRelationship(sourceSpecNodeId, p1, destSpecNodeId) && isValidRelationship(sourceSpecNodeId, p2, destSpecNodeId))
+          continue;
+        const confidence = assessSemanticConfidence(type1, type2), semImpactScore = duplicateImpactScore(confidence), rel1Key = `${group[i].sourceId}|${p1}|${group[i].targetId}`, rel2Key = `${group[j].sourceId}|${p2}|${group[j].targetId}`;
+        candidates.push({
+          relationships: [rel1Key, rel2Key],
+          predicates: [p1, p2],
+          sourceNodeType: sourceSpecNodeId ?? "",
+          destinationNodeType: destSpecNodeId ?? "",
+          reason: `Both predicates '${p1}' and '${p2}' are in "${type1.category}" category between the same element pair`,
+          confidence,
+          impactScore: semImpactScore,
+          alignmentScore: 100 - semImpactScore
+        });
+      }
+  }
+  return candidates;
+}
+function assessSemanticConfidence(type1, type2) {
+  return !type1 || !type2 ? "low" : type1.category === type2.category && type1.semantics.transitivity === type2.semantics.transitivity && type1.semantics.symmetry === type2.semantics.symmetry ? "high" : type1.category === type2.category ? "medium" : "low";
+}
+export {
+  detectModelDuplicates
+};
+//# sourceMappingURL=duplicate-detector.js.map

package/dist/audit/relationships/model/duplicate-detector.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/model/duplicate-detector.ts"],
+  "sourcesContent": ["/**\n * Model Duplicate Detector - Identifies duplicate relationship instances in the model\n *\n * Detects:\n * - Exact duplicates: same (source, predicate, target) triple appearing more than once\n * - Semantic duplicates: same (source_id, target_id) instance pair connected by multiple\n *   predicates in the same semantic category\n */\n\nimport { RelationshipCatalog } from \"../../../core/relationship-catalog.js\";\nimport type { Relationship } from \"../../../core/relationships.js\";\nimport type { Element } from \"../../../core/element.js\";\nimport { duplicateImpactScore, type DuplicateCandidate } from \"../../types.js\";\nimport { isValidRelationship } from \"../../../generated/relationship-index.js\";\n\n/**\n * Detect duplicates within a set of model relationship instances\n */\nexport function detectModelDuplicates(\n  relationships: Relationship[],\n  elements: Element[],\n  catalog: RelationshipCatalog\n): DuplicateCandidate[] {\n  const candidates: DuplicateCandidate[] = [];\n  // Index by both UUID id and path/slug \u2014 relationships store slug paths.\n  const elementById = new Map<string, Element>();\n  for (const e of elements) {\n    elementById.set(e.id, e);\n    if (e.path && e.path !== e.id) elementById.set(e.path, e);\n  }\n\n  // --- Exact duplicates: same (source, predicate, target) ---\n  const exactGroups = new Map<string, Relationship[]>();\n  for (const rel of relationships) {\n    const key = `${rel.source}|${rel.predicate}|${rel.target}`;\n    const group = exactGroups.get(key) ?? [];\n    group.push(rel);\n    exactGroups.set(key, group);\n  }\n\n  for (const [compositeKey, group] of exactGroups) {\n    if (group.length < 2) continue;\n    const rel = group[0];\n    const srcEl = elementById.get(rel.source);\n    const dstEl = elementById.get(rel.target);\n    // Use the composite key as both tuple elements so the differential-analyzer\n    // produces a stable, unique signature for this duplicate pair.\n    const exactImpactScore = duplicateImpactScore(\"high\");\n    candidates.push({\n      relationships: [compositeKey, compositeKey],\n      predicates: [rel.predicate, rel.predicate],\n      sourceNodeType: srcEl?.spec_node_id ?? rel.source,\n      destinationNodeType: dstEl?.spec_node_id ?? rel.target,\n      reason: `Exact duplicate: (${rel.source}, ${rel.predicate}, ${rel.target}) appears ${group.length} times`,\n      confidence: \"high\",\n      impactScore: exactImpactScore,\n      alignmentScore: 100 - exactImpactScore,\n    });\n  }\n\n  // --- Semantic duplicates: same (source_id, target_id) instance pair with same predicate category ---\n  // Group by actual element instance pair so we only flag cases where the same two specific\n  // elements are connected by multiple predicates in the same semantic category. Grouping by\n  // node type instead would flag every pair of elements sharing the same types as duplicates,\n  // producing a false-positive explosion in any well-related model.\n  const semanticGroups = new Map<\n    string,\n    Array<{ predicate: string; sourceId: string; targetId: string; sourceSpecNodeId: string; destSpecNodeId: string }>\n  >();\n\n  for (const rel of relationships) {\n    const srcEl = elementById.get(rel.source);\n    const dstEl = elementById.get(rel.target);\n    if (!srcEl?.spec_node_id || !dstEl?.spec_node_id) continue;\n    const key = `${rel.source}|${rel.target}`;\n    const group = semanticGroups.get(key) ?? [];\n    group.push({ predicate: rel.predicate, sourceId: rel.source, targetId: rel.target, sourceSpecNodeId: srcEl.spec_node_id, destSpecNodeId: dstEl.spec_node_id });\n    semanticGroups.set(key, group);\n  }\n\n  for (const [_key, group] of semanticGroups) {\n    if (group.length < 2) continue;\n    // All entries share the same source/target instance; take type info from the first entry.\n    const sourceSpecNodeId = group[0].sourceSpecNodeId;\n    const destSpecNodeId = group[0].destSpecNodeId;\n\n    // Check all pairs for same-category predicates\n    for (let i = 0; i < group.length; i++) {\n      for (let j = i + 1; j < group.length; j++) {\n        const p1 = group[i].predicate;\n        const p2 = group[j].predicate;\n        if (p1 === p2) continue; // Already caught as exact duplicate above\n\n        const type1 = catalog.getTypeByPredicate(p1);\n        const type2 = catalog.getTypeByPredicate(p2);\n        if (!type1 || !type2) continue;\n        if (type1.category !== type2.category) continue;\n\n        // If both predicates are explicitly spec-valid for this exact source\u2192target node type\n        // pair, the combination is intentional \u2014 not a duplicate. Skip it.\n        if (\n          isValidRelationship(sourceSpecNodeId, p1, destSpecNodeId) &&\n          isValidRelationship(sourceSpecNodeId, p2, destSpecNodeId)\n        ) {\n          continue;\n        }\n\n        const confidence = assessSemanticConfidence(type1, type2);\n        const semImpactScore = duplicateImpactScore(confidence);\n        // Use composite keys of each relationship instance so the differential-analyzer\n        // can build a stable, unique signature for each semantic duplicate pair.\n        const rel1Key = `${group[i].sourceId}|${p1}|${group[i].targetId}`;\n        const rel2Key = `${group[j].sourceId}|${p2}|${group[j].targetId}`;\n        candidates.push({\n          relationships: [rel1Key, rel2Key],\n          predicates: [p1, p2],\n          sourceNodeType: sourceSpecNodeId ?? \"\",\n          destinationNodeType: destSpecNodeId ?? \"\",\n          reason: `Both predicates '${p1}' and '${p2}' are in \"${type1.category}\" category between the same element pair`,\n          confidence,\n          impactScore: semImpactScore,\n          alignmentScore: 100 - semImpactScore,\n        });\n      }\n    }\n  }\n\n  return candidates;\n}\n\nfunction assessSemanticConfidence(\n  type1: ReturnType<RelationshipCatalog[\"getTypeByPredicate\"]>,\n  type2: ReturnType<RelationshipCatalog[\"getTypeByPredicate\"]>\n): \"high\" | \"medium\" | \"low\" {\n  if (!type1 || !type2) return \"low\";\n  if (\n    type1.category === type2.category &&\n    type1.semantics.transitivity === type2.semantics.transitivity &&\n    type1.semantics.symmetry === type2.semantics.symmetry\n  ) {\n    return \"high\";\n  }\n  if (type1.category === type2.category) {\n    return \"medium\";\n  }\n  return \"low\";\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/audit/relationships/model/gap-analyzer.js

@@ -0,0 +1,41 @@
+import { RELATIONSHIPS_BY_SOURCE } from "../../../generated/relationship-index.js";
+import { gapImpactScore } from "../../types.js";
+function analyzeLayerGaps(elements, intraLayerRels) {
+  const candidates = [], presentSpecNodeIds = new Set(elements.map((e) => e.spec_node_id).filter(Boolean)), elementById = /* @__PURE__ */ new Map();
+  for (const e of elements)
+    elementById.set(e.id, e), e.path && e.path !== e.id && elementById.set(e.path, e);
+  const usedCombinations = /* @__PURE__ */ new Set();
+  for (const rel of intraLayerRels) {
+    const srcEl = elementById.get(rel.source), dstEl = elementById.get(rel.target);
+    srcEl?.spec_node_id && dstEl?.spec_node_id && usedCombinations.add(`${srcEl.spec_node_id}|${rel.predicate}|${dstEl.spec_node_id}`);
+  }
+  for (const sourceSpecNodeId of presentSpecNodeIds) {
+    const specRels = RELATIONSHIPS_BY_SOURCE.get(sourceSpecNodeId) ?? [];
+    for (const specRel of specRels) {
+      const { destinationSpecNodeId, predicate, strength } = specRel, srcLayer = sourceSpecNodeId.split(".")[0], dstLayer = destinationSpecNodeId.split(".")[0];
+      if (srcLayer !== dstLayer || !presentSpecNodeIds.has(destinationSpecNodeId))
+        continue;
+      const key = `${sourceSpecNodeId}|${predicate}|${destinationSpecNodeId}`;
+      if (usedCombinations.has(key))
+        continue;
+      const priority = mapStrengthToPriority(strength), impactScore = gapImpactScore(priority);
+      candidates.push({
+        sourceNodeType: sourceSpecNodeId,
+        destinationNodeType: destinationSpecNodeId,
+        suggestedPredicate: predicate,
+        reason: `No '${predicate}' relationship instances found between ${sourceSpecNodeId} and ${destinationSpecNodeId} in the model`,
+        priority,
+        impactScore,
+        alignmentScore: 100 - impactScore
+      });
+    }
+  }
+  return candidates;
+}
+function mapStrengthToPriority(strength) {
+  return strength === "critical" || strength === "high" ? "high" : strength === "medium" ? "medium" : "low";
+}
+export {
+  analyzeLayerGaps
+};
+//# sourceMappingURL=gap-analyzer.js.map

package/dist/audit/relationships/model/gap-analyzer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/model/gap-analyzer.ts"],
+  "sourcesContent": ["/**\n * Model Gap Analyzer - Identifies missing relationship instances in the model\n *\n * For each spec-defined relationship type (source_spec_node_id \u2192 predicate \u2192 dest_spec_node_id):\n * - If both endpoint spec_node_ids have at least one element instance in the model\n * - And zero instances of that (source_type, predicate, dest_type) combination exist\n * - \u2192 Report as a gap\n */\n\nimport { RELATIONSHIPS_BY_SOURCE } from \"../../../generated/relationship-index.js\";\nimport type { Relationship } from \"../../../core/relationships.js\";\nimport type { Element } from \"../../../core/element.js\";\nimport { gapImpactScore, type GapCandidate } from \"../../types.js\";\n\n/**\n * Analyze gaps for a single layer\n */\nexport function analyzeLayerGaps(\n  elements: Element[],\n  intraLayerRels: Relationship[]\n): GapCandidate[] {\n  const candidates: GapCandidate[] = [];\n\n  // Build set of spec_node_ids that have at least one element instance\n  const presentSpecNodeIds = new Set<string>(\n    elements.map((e) => e.spec_node_id).filter(Boolean)\n  );\n\n  // Build set of (source_spec_node_id, predicate, dest_spec_node_id) tuples already in use.\n  // Index by both UUID id and path/slug \u2014 relationships store slug paths.\n  const elementById = new Map<string, Element>();\n  for (const e of elements) {\n    elementById.set(e.id, e);\n    if (e.path && e.path !== e.id) elementById.set(e.path, e);\n  }\n\n  const usedCombinations = new Set<string>();\n  for (const rel of intraLayerRels) {\n    const srcEl = elementById.get(rel.source);\n    const dstEl = elementById.get(rel.target);\n    if (srcEl?.spec_node_id && dstEl?.spec_node_id) {\n      usedCombinations.add(\n        `${srcEl.spec_node_id}|${rel.predicate}|${dstEl.spec_node_id}`\n      );\n    }\n  }\n\n  // Check each spec-defined relationship for the node types present in this layer\n  for (const sourceSpecNodeId of presentSpecNodeIds) {\n    const specRels = RELATIONSHIPS_BY_SOURCE.get(sourceSpecNodeId) ?? [];\n    for (const specRel of specRels) {\n      const { destinationSpecNodeId, predicate, strength } = specRel;\n\n      // Only consider intra-layer gaps (same layer prefix)\n      const srcLayer = sourceSpecNodeId.split(\".\")[0];\n      const dstLayer = destinationSpecNodeId.split(\".\")[0];\n      if (srcLayer !== dstLayer) {\n        continue;\n      }\n\n      // Both sides must have instances in the model\n      if (!presentSpecNodeIds.has(destinationSpecNodeId)) {\n        continue;\n      }\n\n      // Skip if at least one instance of this combination already exists\n      const key = `${sourceSpecNodeId}|${predicate}|${destinationSpecNodeId}`;\n      if (usedCombinations.has(key)) {\n        continue;\n      }\n\n      const priority = mapStrengthToPriority(strength);\n      const impactScore = gapImpactScore(priority);\n      candidates.push({\n        sourceNodeType: sourceSpecNodeId,\n        destinationNodeType: destinationSpecNodeId,\n        suggestedPredicate: predicate,\n        reason: `No '${predicate}' relationship instances found between ${sourceSpecNodeId} and ${destinationSpecNodeId} in the model`,\n        priority,\n        impactScore,\n        alignmentScore: 100 - impactScore,\n      });\n    }\n  }\n\n  return candidates;\n}\n\nfunction mapStrengthToPriority(\n  strength: \"critical\" | \"high\" | \"medium\" | \"low\"\n): \"high\" | \"medium\" | \"low\" {\n  if (strength === \"critical\" || strength === \"high\") {\n    return \"high\";\n  }\n  if (strength === \"medium\") {\n    return \"medium\";\n  }\n  return \"low\";\n}\n"],
+  "mappings": "AASA,SAAS,+BAA+B;AAGxC,SAAS,sBAAyC;AAK5C,SAAU,iBACd,UACA,gBAA8B;AAE9B,QAAM,aAA6B,CAAA,GAG7B,qBAAqB,IAAI,IAC7B,SAAS,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,OAAO,CAAC,GAK/C,cAAc,oBAAI,IAAG;AAC3B,aAAW,KAAK;AACd,gBAAY,IAAI,EAAE,IAAI,CAAC,GACnB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAI,YAAY,IAAI,EAAE,MAAM,CAAC;AAG1D,QAAM,mBAAmB,oBAAI,IAAG;AAChC,aAAW,OAAO,gBAAgB;AAChC,UAAM,QAAQ,YAAY,IAAI,IAAI,MAAM,GAClC,QAAQ,YAAY,IAAI,IAAI,MAAM;AACxC,IAAI,OAAO,gBAAgB,OAAO,gBAChC,iBAAiB,IACf,GAAG,MAAM,YAAY,IAAI,IAAI,SAAS,IAAI,MAAM,YAAY,EAAE;EAGpE;AAGA,aAAW,oBAAoB,oBAAoB;AACjD,UAAM,WAAW,wBAAwB,IAAI,gBAAgB,KAAK,CAAA;AAClE,eAAW,WAAW,UAAU;AAC9B,YAAM,EAAE,uBAAuB,WAAW,SAAQ,IAAK,SAGjD,WAAW,iBAAiB,MAAM,GAAG,EAAE,CAAC,GACxC,WAAW,sBAAsB,MAAM,GAAG,EAAE,CAAC;AAMnD,UALI,aAAa,YAKb,CAAC,mBAAmB,IAAI,qBAAqB;AAC/C;AAIF,YAAM,MAAM,GAAG,gBAAgB,IAAI,SAAS,IAAI,qBAAqB;AACrE,UAAI,iBAAiB,IAAI,GAAG;AAC1B;AAGF,YAAM,WAAW,sBAAsB,QAAQ,GACzC,cAAc,eAAe,QAAQ;AAC3C,iBAAW,KAAK;QACd,gBAAgB;QAChB,qBAAqB;QACrB,oBAAoB;QACpB,QAAQ,OAAO,SAAS,0CAA0C,gBAAgB,QAAQ,qBAAqB;QAC/G;QACA;QACA,gBAAgB,MAAM;OACvB;IACH;EACF;AAEA,SAAO;AACT;AAEA,SAAS,sBACP,UAAgD;AAEhD,SAAI,aAAa,cAAc,aAAa,SACnC,SAEL,aAAa,WACR,WAEF;AACT;",
+  "names": []
+}

package/dist/audit/relationships/model/orchestrator.js

@@ -0,0 +1,126 @@
+import { Model } from "../../../core/model.js";
+import { RelationshipCatalog } from "../../../core/relationship-catalog.js";
+import { RelationshipGraph } from "../graph/relationship-graph.js";
+import { ConnectivityAnalyzer } from "../graph/connectivity.js";
+import { analyzeLayerCoverage } from "./coverage-analyzer.js";
+import { analyzeLayerGaps } from "./gap-analyzer.js";
+import { detectModelDuplicates } from "./duplicate-detector.js";
+import { assessLayerBalance } from "./balance-assessor.js";
+import { getAllLayers, getLayerById } from "../../../generated/layer-registry.js";
+class ModelAuditOrchestrator {
+  catalog;
+  graph;
+  initialized = !1;
+  constructor() {
+    this.catalog = new RelationshipCatalog(), this.graph = new RelationshipGraph();
+  }
+  async initialize() {
+    this.initialized || (await this.catalog.load(), this.initialized = !0);
+  }
+  /**
+   * Get predicates applicable to a specific layer (same API as AuditOrchestrator)
+   */
+  getPredicatesForLayer(layer) {
+    return this.catalog.getTypesForLayer(layer).map((t) => t.predicate);
+  }
+  /**
+   * Run complete audit against the project model
+   */
+  async runAudit(options = {}) {
+    await this.initialize();
+    const projectRoot = options.projectRoot ?? process.cwd();
+    let model;
+    try {
+      model = await Model.load(projectRoot);
+    } catch (err) {
+      throw new Error(`Failed to load project model from ${projectRoot}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const allElements = [];
+    for (const layer of model.layers.values())
+      for (const el of layer.elements.values())
+        allElements.push(el);
+    const elementById = /* @__PURE__ */ new Map();
+    for (const e of allElements)
+      elementById.set(e.id, e), e.path && e.path !== e.id && elementById.set(e.path, e);
+    const allRelationships = model.relationships.getAll(), getElementLayer = (el) => el.layer_id || el.layer || "", elementsByLayer = /* @__PURE__ */ new Map();
+    for (const el of allElements) {
+      const layerId = getElementLayer(el);
+      if (!layerId)
+        continue;
+      const list = elementsByLayer.get(layerId) ?? [];
+      list.push(el), elementsByLayer.set(layerId, list);
+    }
+    const intraRelsByLayer = /* @__PURE__ */ new Map(), interRelsByLayer = /* @__PURE__ */ new Map(), incomingInterRelsByLayer = /* @__PURE__ */ new Map();
+    for (const rel of allRelationships) {
+      const srcEl = elementById.get(rel.source), dstEl = elementById.get(rel.target);
+      if (!srcEl || !dstEl)
+        continue;
+      const srcLayer = getElementLayer(srcEl), dstLayer = getElementLayer(dstEl);
+      if (srcLayer)
+        if (srcLayer === dstLayer) {
+          const list = intraRelsByLayer.get(srcLayer) ?? [];
+          list.push(rel), intraRelsByLayer.set(srcLayer, list);
+        } else {
+          const outList = interRelsByLayer.get(srcLayer) ?? [];
+          if (outList.push(rel), interRelsByLayer.set(srcLayer, outList), dstLayer) {
+            const inList = incomingInterRelsByLayer.get(dstLayer) ?? [];
+            inList.push(rel), incomingInterRelsByLayer.set(dstLayer, inList);
+          }
+        }
+    }
+    const layersToAnalyze = this.resolveTargetLayers(options.layer), coverage = [], gaps = [], balance = [];
+    for (const layerMeta of layersToAnalyze) {
+      const layerId = layerMeta.id, layerElements = elementsByLayer.get(layerId) ?? [], layerRels = intraRelsByLayer.get(layerId) ?? [], layerInterRels2 = [
+        ...interRelsByLayer.get(layerId) ?? [],
+        ...incomingInterRelsByLayer.get(layerId) ?? []
+      ];
+      coverage.push(analyzeLayerCoverage(layerId, layerElements, layerRels, layerInterRels2, this.catalog)), gaps.push(...analyzeLayerGaps(layerElements, layerRels)), balance.push(...assessLayerBalance(layerId, layerElements, layerRels));
+    }
+    const relsForDuplicates = options.layer ? intraRelsByLayer.get(options.layer) ?? [] : allRelationships, elementsForDuplicates = options.layer ? elementsByLayer.get(options.layer) ?? [] : allElements, duplicates = detectModelDuplicates(relsForDuplicates, elementsForDuplicates, this.catalog), layerOutgoingInterRels = options.layer ? interRelsByLayer.get(options.layer) ?? [] : [], layerIncomingInterRels = options.layer ? incomingInterRelsByLayer.get(options.layer) ?? [] : [], layerInterRels = [...layerOutgoingInterRels, ...layerIncomingInterRels], relsForGraph = options.layer ? [...intraRelsByLayer.get(options.layer) ?? [], ...layerInterRels] : allRelationships, crossLayerTargetIds = new Set(layerOutgoingInterRels.map((r) => r.target)), crossLayerSourceIds = new Set(layerIncomingInterRels.map((r) => r.source)), crossLayerAdjacentElements = allElements.filter((e) => crossLayerTargetIds.has(e.id) || e.path != null && crossLayerTargetIds.has(e.path) || crossLayerSourceIds.has(e.id) || e.path != null && crossLayerSourceIds.has(e.path)), elementsForGraph = options.layer ? [...elementsByLayer.get(options.layer) ?? [], ...crossLayerAdjacentElements] : allElements;
+    this.graph.buildFromModel(relsForGraph, elementsForGraph);
+    const connectivityAnalyzer = new ConnectivityAnalyzer(this.graph, this.catalog), components = connectivityAnalyzer.findConnectedComponents(), degrees = connectivityAnalyzer.calculateDegreeDistribution(), transitiveChains = await connectivityAnalyzer.findTransitiveChains(), rawStats = connectivityAnalyzer.getConnectivityStats(), connectivityStats = {
+      totalNodes: rawStats.nodeCount,
+      totalEdges: rawStats.edgeCount,
+      connectedComponents: rawStats.componentCount,
+      largestComponentSize: rawStats.largestComponentSize,
+      isolatedNodes: rawStats.isolatedNodeCount,
+      averageDegree: rawStats.averageDegree,
+      transitiveChainCount: transitiveChains.length
+    }, modelMetadata = {
+      name: model.manifest.name ?? "Documentation Robotics Model",
+      version: model.manifest.version ?? "1.0.0"
+    };
+    return this.log(options, "Generating model audit report..."), {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: modelMetadata,
+      coverage,
+      duplicates,
+      gaps,
+      balance,
+      connectivity: {
+        components,
+        degrees,
+        transitiveChains,
+        stats: connectivityStats
+      }
+    };
+  }
+  resolveTargetLayers(layerFilter) {
+    if (layerFilter) {
+      const layer = getLayerById(layerFilter);
+      if (!layer) {
+        const valid = getAllLayers().map((l) => l.id).join(", ");
+        throw new Error(`Layer not found: '${layerFilter}'. Valid layers: ${valid}`);
+      }
+      return [layer];
+    }
+    return getAllLayers();
+  }
+  log(options, message) {
+    (options.verbose || options.debug) && console.error(message);
+  }
+}
+export {
+  ModelAuditOrchestrator
+};
+//# sourceMappingURL=orchestrator.js.map

package/dist/audit/relationships/model/orchestrator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/model/orchestrator.ts"],
+  "sourcesContent": ["/**\n * Model Audit Orchestrator - Runs audit analysis against the project's actual model\n *\n * Loads the project model via Model.fromDirectory() and runs the four model-specific\n * analyzers (coverage, gaps, duplicates, balance) plus connectivity, producing an\n * AuditReport in the same format as AuditOrchestrator.\n */\n\nimport { Model } from \"../../../core/model.js\";\nimport { RelationshipCatalog } from \"../../../core/relationship-catalog.js\";\nimport { RelationshipGraph } from \"../graph/relationship-graph.js\";\nimport { ConnectivityAnalyzer } from \"../graph/connectivity.js\";\nimport { analyzeLayerCoverage } from \"./coverage-analyzer.js\";\nimport { analyzeLayerGaps } from \"./gap-analyzer.js\";\nimport { detectModelDuplicates } from \"./duplicate-detector.js\";\nimport { assessLayerBalance } from \"./balance-assessor.js\";\nimport { getAllLayers, getLayerById } from \"../../../generated/layer-registry.js\";\nimport type { Element } from \"../../../core/element.js\";\nimport type { Relationship } from \"../../../core/relationships.js\";\nimport type {\n  AuditReport,\n  ConnectivityStats,\n  CoverageMetrics,\n  DuplicateCandidate,\n  GapCandidate,\n  BalanceAssessment,\n} from \"../../types.js\";\n\nexport interface ModelAuditOptions {\n  layer?: string;\n  verbose?: boolean;\n  debug?: boolean;\n  projectRoot?: string;\n}\n\n/**\n * Orchestrates audit of the project's model relationship instances\n */\nexport class ModelAuditOrchestrator {\n  private catalog: RelationshipCatalog;\n  private graph: RelationshipGraph;\n  private initialized = false;\n\n  constructor() {\n    this.catalog = new RelationshipCatalog();\n    this.graph = new RelationshipGraph();\n  }\n\n  async initialize(): Promise<void> {\n    if (!this.initialized) {\n      await this.catalog.load();\n      this.initialized = true;\n    }\n  }\n\n  /**\n   * Get predicates applicable to a specific layer (same API as AuditOrchestrator)\n   */\n  getPredicatesForLayer(layer: string): string[] {\n    return this.catalog.getTypesForLayer(layer).map((t) => t.predicate);\n  }\n\n  /**\n   * Run complete audit against the project model\n   */\n  async runAudit(options: ModelAuditOptions = {}): Promise<AuditReport> {\n    await this.initialize();\n\n    const projectRoot = options.projectRoot ?? process.cwd();\n\n    // Load model (layers + relationships)\n    let model: Model;\n    try {\n      model = await Model.load(projectRoot);\n    } catch (err) {\n      throw new Error(\n        `Failed to load project model from ${projectRoot}: ${err instanceof Error ? err.message : String(err)}`\n      );\n    }\n\n    // Collect all elements across all layers\n    const allElements: Element[] = [];\n    for (const layer of model.layers.values()) {\n      for (const el of layer.elements.values()) {\n        allElements.push(el);\n      }\n    }\n\n    // Build element lookup by both UUID id and path/slug (for resolving relationship\n    // endpoints, which are stored as slug paths in relationships.yaml).\n    const elementById = new Map<string, Element>();\n    for (const e of allElements) {\n      elementById.set(e.id, e);\n      if (e.path && e.path !== e.id) elementById.set(e.path, e);\n    }\n\n    // All relationship instances from relationships.yaml\n    const allRelationships: Relationship[] = model.relationships.getAll();\n\n    // Resolve canonical layer for each element\n    // Elements may have layer_id (spec-aligned) or layer (legacy) set\n    const getElementLayer = (el: Element): string =>\n      el.layer_id || el.layer || \"\";\n\n    // Build per-layer element and intra-layer relationship maps\n    const elementsByLayer = new Map<string, Element[]>();\n    for (const el of allElements) {\n      const layerId = getElementLayer(el);\n      if (!layerId) continue;\n      const list = elementsByLayer.get(layerId) ?? [];\n      list.push(el);\n      elementsByLayer.set(layerId, list);\n    }\n\n    // Intra-layer rels: both source and target element are in the same layer\n    const intraRelsByLayer = new Map<string, Relationship[]>();\n    // Inter-layer rels keyed by source layer (outgoing)\n    const interRelsByLayer = new Map<string, Relationship[]>();\n    // Inter-layer rels keyed by destination layer (incoming)\n    const incomingInterRelsByLayer = new Map<string, Relationship[]>();\n    for (const rel of allRelationships) {\n      const srcEl = elementById.get(rel.source);\n      const dstEl = elementById.get(rel.target);\n      if (!srcEl || !dstEl) continue;\n      const srcLayer = getElementLayer(srcEl);\n      const dstLayer = getElementLayer(dstEl);\n      if (!srcLayer) continue;\n      if (srcLayer === dstLayer) {\n        const list = intraRelsByLayer.get(srcLayer) ?? [];\n        list.push(rel);\n        intraRelsByLayer.set(srcLayer, list);\n      } else {\n        const outList = interRelsByLayer.get(srcLayer) ?? [];\n        outList.push(rel);\n        interRelsByLayer.set(srcLayer, outList);\n        if (dstLayer) {\n          const inList = incomingInterRelsByLayer.get(dstLayer) ?? [];\n          inList.push(rel);\n          incomingInterRelsByLayer.set(dstLayer, inList);\n        }\n      }\n    }\n\n    // Determine which layers to analyze\n    const layersToAnalyze = this.resolveTargetLayers(options.layer);\n\n    // --- Run per-layer analysis ---\n    const coverage: CoverageMetrics[] = [];\n    const gaps: GapCandidate[] = [];\n    const balance: BalanceAssessment[] = [];\n\n    for (const layerMeta of layersToAnalyze) {\n      const layerId = layerMeta.id;\n      const layerElements = elementsByLayer.get(layerId) ?? [];\n      const layerRels = intraRelsByLayer.get(layerId) ?? [];\n      // Include both outgoing (source=this layer) and incoming (target=this layer) inter-layer rels\n      const layerInterRels = [\n        ...(interRelsByLayer.get(layerId) ?? []),\n        ...(incomingInterRelsByLayer.get(layerId) ?? []),\n      ];\n\n      coverage.push(\n        analyzeLayerCoverage(layerId, layerElements, layerRels, layerInterRels, this.catalog)\n      );\n      gaps.push(...analyzeLayerGaps(layerElements, layerRels));\n      balance.push(...assessLayerBalance(layerId, layerElements, layerRels));\n    }\n\n    // --- Duplicates (cross-layer or per-layer, depending on filter) ---\n    const relsForDuplicates = options.layer\n      ? (intraRelsByLayer.get(options.layer) ?? [])\n      : allRelationships;\n    const elementsForDuplicates = options.layer\n      ? (elementsByLayer.get(options.layer) ?? [])\n      : allElements;\n\n    const duplicates: DuplicateCandidate[] = detectModelDuplicates(\n      relsForDuplicates,\n      elementsForDuplicates,\n      this.catalog\n    );\n\n    // --- Connectivity ---\n    // For per-layer audits, include both outgoing and incoming inter-layer rels so that\n    // node types are not incorrectly classified as isolated when they only have cross-layer\n    // connections (in either direction). Also include adjacent elements from both sides so\n    // buildFromModel can resolve all relationship endpoints.\n    const layerOutgoingInterRels = options.layer ? (interRelsByLayer.get(options.layer) ?? []) : [];\n    const layerIncomingInterRels = options.layer ? (incomingInterRelsByLayer.get(options.layer) ?? []) : [];\n    const layerInterRels = [...layerOutgoingInterRels, ...layerIncomingInterRels];\n    const relsForGraph = options.layer\n      ? [...(intraRelsByLayer.get(options.layer) ?? []), ...layerInterRels]\n      : allRelationships;\n    const crossLayerTargetIds = new Set<string>(layerOutgoingInterRels.map((r) => r.target));\n    const crossLayerSourceIds = new Set<string>(layerIncomingInterRels.map((r) => r.source));\n    const crossLayerAdjacentElements = allElements.filter(\n      (e) =>\n        crossLayerTargetIds.has(e.id) ||\n        (e.path != null && crossLayerTargetIds.has(e.path)) ||\n        crossLayerSourceIds.has(e.id) ||\n        (e.path != null && crossLayerSourceIds.has(e.path))\n    );\n    const elementsForGraph = options.layer\n      ? [...(elementsByLayer.get(options.layer) ?? []), ...crossLayerAdjacentElements]\n      : allElements;\n\n    this.graph.buildFromModel(relsForGraph, elementsForGraph);\n\n    // Create a fresh ConnectivityAnalyzer each run so its internal caches\n    // (cachedComponents, cachedDegrees) always reflect the current graph state.\n    const connectivityAnalyzer = new ConnectivityAnalyzer(this.graph, this.catalog);\n    const components = connectivityAnalyzer.findConnectedComponents();\n    const degrees = connectivityAnalyzer.calculateDegreeDistribution();\n    const transitiveChains = await connectivityAnalyzer.findTransitiveChains();\n    const rawStats = connectivityAnalyzer.getConnectivityStats();\n\n    const connectivityStats: ConnectivityStats = {\n      totalNodes: rawStats.nodeCount,\n      totalEdges: rawStats.edgeCount,\n      connectedComponents: rawStats.componentCount,\n      largestComponentSize: rawStats.largestComponentSize,\n      isolatedNodes: rawStats.isolatedNodeCount,\n      averageDegree: rawStats.averageDegree,\n      transitiveChainCount: transitiveChains.length,\n    };\n\n    // Model metadata\n    const modelMetadata = {\n      name: model.manifest.name ?? \"Documentation Robotics Model\",\n      version: model.manifest.version ?? \"1.0.0\",\n    };\n\n    this.log(options, \"Generating model audit report...\");\n\n    return {\n      timestamp: new Date().toISOString(),\n      model: modelMetadata,\n      coverage,\n      duplicates,\n      gaps,\n      balance,\n      connectivity: {\n        components,\n        degrees,\n        transitiveChains,\n        stats: connectivityStats,\n      },\n    };\n  }\n\n  private resolveTargetLayers(layerFilter?: string) {\n    if (layerFilter) {\n      const layer = getLayerById(layerFilter);\n      if (!layer) {\n        const valid = getAllLayers()\n          .map((l) => l.id)\n          .join(\", \");\n        throw new Error(\n          `Layer not found: '${layerFilter}'. Valid layers: ${valid}`\n        );\n      }\n      return [layer];\n    }\n    return getAllLayers();\n  }\n\n  private log(options: ModelAuditOptions, message: string): void {\n    if (options.verbose || options.debug) {\n      console.error(message);\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["layerInterRels"]
+}