@documentation-robotics/cli 0.1.0 → 0.1.5

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

@@ -0,0 +1,115 @@
+import { RELATIONSHIPS_BY_SOURCE } from "../../../generated/relationship-index.js";
+import { getAllLayers } from "../../../generated/layer-registry.js";
+const DENSITY_TARGETS = {
+  structural: [2, 4],
+  // Entities, components
+  behavioral: [3, 5],
+  // Processes, services
+  enumeration: [1, 2],
+  // States, values
+  reference: [0, 1]
+  // Metadata, tags
+};
+class BalanceAssessor {
+  assessmentCache = null;
+  /**
+   * Assess balance for all layers
+   */
+  assessAll() {
+    if (this.assessmentCache !== null)
+      return this.assessmentCache;
+    const layers = getAllLayers(), assessments = [];
+    for (const layer of layers) {
+      const layerAssessments = this.assessLayer(layer);
+      assessments.push(...layerAssessments);
+    }
+    return this.assessmentCache = assessments, assessments;
+  }
+  /**
+   * Assess balance for a single layer
+   */
+  assessLayer(layer) {
+    const assessments = [];
+    for (const nodeType of layer.nodeTypes) {
+      const assessment = this.assessNodeType(nodeType, layer.id);
+      assessments.push(assessment);
+    }
+    return assessments;
+  }
+  /**
+   * Assess balance for a single node type
+   */
+  assessNodeType(nodeType, layerId) {
+    const category = this.classifyNodeType(nodeType), currentCount = this.getRelationshipCount(nodeType), targetRange = DENSITY_TARGETS[category], status = this.determineStatus(currentCount, targetRange), recommendation = this.generateRecommendation(nodeType, category, currentCount, targetRange, status);
+    return {
+      nodeType,
+      layer: layerId,
+      category,
+      currentCount,
+      targetRange,
+      status,
+      recommendation
+    };
+  }
+  /**
+   * Classify node type into category
+   *
+   * IMPORTANT: Categories are checked in precedence order:
+   * 1. Enumeration (most specific - uses endsWith)
+   * 2. Structural (uses includes - may match substrings)
+   * 3. Behavioral (uses includes - may match substrings)
+   * 4. Reference (default)
+   *
+   * The ordering matters because includes() can match substrings.
+   * For example, "businessservice" contains "service" (structural)
+   * but is behavioral by nature. The current implementation favors
+   * structural classification in such cases.
+   */
+  classifyNodeType(specNodeId) {
+    const type = specNodeId.split(".")[1] || "";
+    return type ? 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" : (console.warn(`Warning: Could not extract type from specNodeId '${specNodeId}', defaulting to 'reference' classification`), "reference");
+  }
+  /**
+   * Get relationship count for node type
+   */
+  getRelationshipCount(nodeType) {
+    return (RELATIONSHIPS_BY_SOURCE.get(nodeType) || []).length;
+  }
+  /**
+   * Determine balance status
+   */
+  determineStatus(count, targetRange) {
+    const [min, max] = targetRange;
+    return count < min ? "under" : count > max ? "over" : "balanced";
+  }
+  /**
+   * Generate recommendation
+   */
+  generateRecommendation(nodeType, category, currentCount, targetRange, status) {
+    const [min, max] = targetRange, typeName = nodeType.split(".").pop() || nodeType;
+    if (status === "under") {
+      const needed = min - currentCount;
+      return `Add ${needed} relationship${needed > 1 ? "s" : ""} to ${typeName} (${category} type) to reach minimum target`;
+    }
+    if (status === "over") {
+      const excess = currentCount - max;
+      return `Consider removing ${excess} relationship${excess > 1 ? "s" : ""} from ${typeName} or reviewing ${category} type classification`;
+    }
+  }
+  /**
+   * Get assessments by status
+   */
+  assessByStatus(status) {
+    return this.assessAll().filter((a) => a.status === status);
+  }
+  /**
+   * Get assessments by category
+   */
+  assessByCategory(category) {
+    return this.assessAll().filter((a) => a.category === category);
+  }
+}
+export {
+  BalanceAssessor
+};
+//# sourceMappingURL=balance-assessor.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/analysis/balance-assessor.ts"],
+  "sourcesContent": ["/**\n * Balance Assessor - Assesses relationship density balance\n *\n * Applies heuristics to determine if node types have appropriate\n * numbers of relationships based on their category:\n * - Structural (2-4 relationships): entities, components\n * - Behavioral (3-5 relationships): processes, services\n * - Enumeration (1-2 relationships): states, values\n * - Reference (0-1 relationships): metadata, tags\n */\n\nimport { RELATIONSHIPS_BY_SOURCE } from \"../../../generated/relationship-index.js\";\nimport {\n  getAllLayers,\n  type LayerMetadata,\n} from \"../../../generated/layer-registry.js\";\nimport type { BalanceAssessment } from \"../../types.js\";\n\n/**\n * Density targets for different node type categories\n */\nconst DENSITY_TARGETS: Record<string, [number, number]> = {\n  structural: [2, 4], // Entities, components\n  behavioral: [3, 5], // Processes, services\n  enumeration: [1, 2], // States, values\n  reference: [0, 1], // Metadata, tags\n};\n\n/**\n * Balance assessor for relationship density\n */\nexport class BalanceAssessor {\n  private assessmentCache: BalanceAssessment[] | null = null;\n\n  /**\n   * Assess balance for all layers\n   */\n  assessAll(): BalanceAssessment[] {\n    if (this.assessmentCache !== null) {\n      return this.assessmentCache;\n    }\n\n    const layers = getAllLayers();\n    const assessments: BalanceAssessment[] = [];\n\n    for (const layer of layers) {\n      const layerAssessments = this.assessLayer(layer);\n      assessments.push(...layerAssessments);\n    }\n\n    this.assessmentCache = assessments;\n    return assessments;\n  }\n\n  /**\n   * Assess balance for a single layer\n   */\n  assessLayer(layer: LayerMetadata): BalanceAssessment[] {\n    const assessments: BalanceAssessment[] = [];\n\n    for (const nodeType of layer.nodeTypes) {\n      const assessment = this.assessNodeType(nodeType, layer.id);\n      assessments.push(assessment);\n    }\n\n    return assessments;\n  }\n\n  /**\n   * Assess balance for a single node type\n   */\n  private assessNodeType(\n    nodeType: string,\n    layerId: string\n  ): BalanceAssessment {\n    const category = this.classifyNodeType(nodeType);\n    const currentCount = this.getRelationshipCount(nodeType);\n    const targetRange = DENSITY_TARGETS[category];\n    const status = this.determineStatus(currentCount, targetRange);\n    const recommendation = this.generateRecommendation(\n      nodeType,\n      category,\n      currentCount,\n      targetRange,\n      status\n    );\n\n    return {\n      nodeType,\n      layer: layerId,\n      category,\n      currentCount,\n      targetRange,\n      status,\n      recommendation,\n    };\n  }\n\n  /**\n   * Classify node type into category\n   *\n   * IMPORTANT: Categories are checked in precedence order:\n   * 1. Enumeration (most specific - uses endsWith)\n   * 2. Structural (uses includes - may match substrings)\n   * 3. Behavioral (uses includes - may match substrings)\n   * 4. Reference (default)\n   *\n   * The ordering matters because includes() can match substrings.\n   * For example, \"businessservice\" contains \"service\" (structural)\n   * but is behavioral by nature. The current implementation favors\n   * structural classification in such cases.\n   */\n  private classifyNodeType(\n    specNodeId: string\n  ): \"structural\" | \"behavioral\" | \"enumeration\" | \"reference\" {\n    const type = specNodeId.split(\".\")[1] || \"\";\n\n    // Warn if type extraction fails (unexpected specNodeId format)\n    if (!type) {\n      console.warn(`Warning: Could not extract type from specNodeId '${specNodeId}', defaulting to 'reference' classification`);\n      return \"reference\";\n    }\n\n    // Enumeration patterns - checked first (most specific, uses endsWith)\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    // Structural patterns - checked second\n    // NOTE: Uses includes() which may match substrings (e.g., \"businessservice\" matches \"service\")\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    // Behavioral patterns - checked third\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    // Default to reference for unmatched types\n    return \"reference\";\n  }\n\n  /**\n   * Get relationship count for node type\n   */\n  private getRelationshipCount(nodeType: string): number {\n    const relationships = RELATIONSHIPS_BY_SOURCE.get(nodeType) || [];\n    return relationships.length;\n  }\n\n  /**\n   * Determine balance status\n   */\n  private determineStatus(\n    count: number,\n    targetRange: [number, number]\n  ): \"under\" | \"balanced\" | \"over\" {\n    const [min, max] = targetRange;\n\n    if (count < min) {\n      return \"under\";\n    }\n    if (count > max) {\n      return \"over\";\n    }\n    return \"balanced\";\n  }\n\n  /**\n   * Generate recommendation\n   */\n  private generateRecommendation(\n    nodeType: 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 = nodeType.split(\".\").pop() || nodeType;\n\n    if (status === \"under\") {\n      const needed = min - currentCount;\n      return `Add ${needed} relationship${needed > 1 ? \"s\" : \"\"} to ${typeName} (${category} type) to reach minimum target`;\n    }\n\n    if (status === \"over\") {\n      const excess = currentCount - max;\n      return `Consider removing ${excess} relationship${excess > 1 ? \"s\" : \"\"} from ${typeName} or reviewing ${category} type classification`;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Get assessments by status\n   */\n  assessByStatus(\n    status: \"under\" | \"balanced\" | \"over\"\n  ): BalanceAssessment[] {\n    const all = this.assessAll();\n    return all.filter((a) => a.status === status);\n  }\n\n  /**\n   * Get assessments by category\n   */\n  assessByCategory(\n    category: \"structural\" | \"behavioral\" | \"enumeration\" | \"reference\"\n  ): BalanceAssessment[] {\n    const all = this.assessAll();\n    return all.filter((a) => a.category === category);\n  }\n}\n"],
+  "mappings": "AAWA,SAAS,+BAA+B;AACxC,SACE,oBAEK;AAMP,MAAM,kBAAoD;EACxD,YAAY,CAAC,GAAG,CAAC;;EACjB,YAAY,CAAC,GAAG,CAAC;;EACjB,aAAa,CAAC,GAAG,CAAC;;EAClB,WAAW,CAAC,GAAG,CAAC;;;AAMZ,MAAO,gBAAe;EAClB,kBAA8C;;;;EAKtD,YAAS;AACP,QAAI,KAAK,oBAAoB;AAC3B,aAAO,KAAK;AAGd,UAAM,SAAS,aAAY,GACrB,cAAmC,CAAA;AAEzC,eAAW,SAAS,QAAQ;AAC1B,YAAM,mBAAmB,KAAK,YAAY,KAAK;AAC/C,kBAAY,KAAK,GAAG,gBAAgB;IACtC;AAEA,gBAAK,kBAAkB,aAChB;EACT;;;;EAKA,YAAY,OAAoB;AAC9B,UAAM,cAAmC,CAAA;AAEzC,eAAW,YAAY,MAAM,WAAW;AACtC,YAAM,aAAa,KAAK,eAAe,UAAU,MAAM,EAAE;AACzD,kBAAY,KAAK,UAAU;IAC7B;AAEA,WAAO;EACT;;;;EAKQ,eACN,UACA,SAAe;AAEf,UAAM,WAAW,KAAK,iBAAiB,QAAQ,GACzC,eAAe,KAAK,qBAAqB,QAAQ,GACjD,cAAc,gBAAgB,QAAQ,GACtC,SAAS,KAAK,gBAAgB,cAAc,WAAW,GACvD,iBAAiB,KAAK,uBAC1B,UACA,UACA,cACA,aACA,MAAM;AAGR,WAAO;MACL;MACA,OAAO;MACP;MACA;MACA;MACA;MACA;;EAEJ;;;;;;;;;;;;;;;EAgBQ,iBACN,YAAkB;AAElB,UAAM,OAAO,WAAW,MAAM,GAAG,EAAE,CAAC,KAAK;AAGzC,WAAK,OAOH,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,gBAMP,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,eAKP,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,eAIF,eAhDL,QAAQ,KAAK,oDAAoD,UAAU,6CAA6C,GACjH;EAgDX;;;;EAKQ,qBAAqB,UAAgB;AAE3C,YADsB,wBAAwB,IAAI,QAAQ,KAAK,CAAA,GAC1C;EACvB;;;;EAKQ,gBACN,OACA,aAA6B;AAE7B,UAAM,CAAC,KAAK,GAAG,IAAI;AAEnB,WAAI,QAAQ,MACH,UAEL,QAAQ,MACH,SAEF;EACT;;;;EAKQ,uBACN,UACA,UACA,cACA,aACA,QAAqC;AAErC,UAAM,CAAC,KAAK,GAAG,IAAI,aACb,WAAW,SAAS,MAAM,GAAG,EAAE,IAAG,KAAM;AAE9C,QAAI,WAAW,SAAS;AACtB,YAAM,SAAS,MAAM;AACrB,aAAO,OAAO,MAAM,gBAAgB,SAAS,IAAI,MAAM,EAAE,OAAO,QAAQ,KAAK,QAAQ;IACvF;AAEA,QAAI,WAAW,QAAQ;AACrB,YAAM,SAAS,eAAe;AAC9B,aAAO,qBAAqB,MAAM,gBAAgB,SAAS,IAAI,MAAM,EAAE,SAAS,QAAQ,iBAAiB,QAAQ;IACnH;EAGF;;;;EAKA,eACE,QAAqC;AAGrC,WADY,KAAK,UAAS,EACf,OAAO,CAAC,MAAM,EAAE,WAAW,MAAM;EAC9C;;;;EAKA,iBACE,UAAmE;AAGnE,WADY,KAAK,UAAS,EACf,OAAO,CAAC,MAAM,EAAE,aAAa,QAAQ;EAClD;;",
+  "names": []
+}

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

@@ -0,0 +1,99 @@
+import { RELATIONSHIPS_BY_SOURCE } from "../../../generated/relationship-index.js";
+import { getAllLayers } from "../../../generated/layer-registry.js";
+import { LAYER_TEMPLATES } from "./layer-templates.js";
+import { createPercentage } from "../../types.js";
+class CoverageAnalyzer {
+  catalog;
+  constructor(catalog) {
+    this.catalog = catalog;
+  }
+  /**
+   * Analyze coverage for all layers
+   * @returns Result object indicating success/partial/failure with complete flag
+   */
+  async analyzeAll() {
+    const layers = getAllLayers(), results = [], errors = [];
+    for (const layer of layers)
+      try {
+        const metrics = await this.analyzeLayer(layer);
+        results.push(metrics);
+      } catch (error) {
+        errors.push({
+          layer: layer.id,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    if (results.length === 0 && errors.length > 0)
+      throw errors[0].error;
+    if (errors.length > 0 && results.length > 0) {
+      console.error(`
+\u26A0\uFE0F  Warning: Coverage analysis failed for ${errors.length} layer(s):`);
+      for (const { layer, error } of errors)
+        console.error(`  - ${layer}: ${error.message}`);
+      console.error(`
+Successfully analyzed ${results.length}/${layers.length} layers.
+`);
+    }
+    return {
+      results,
+      failures: errors,
+      isComplete: errors.length === 0
+    };
+  }
+  /**
+   * Analyze coverage for a single layer
+   */
+  async analyzeLayer(layer) {
+    const nodeTypes = layer.nodeTypes, nodeTypeCount = nodeTypes.length, relationshipCounts = /* @__PURE__ */ new Map(), usedPredicatesSet = /* @__PURE__ */ new Set();
+    for (const nodeType of nodeTypes) {
+      const relationships = RELATIONSHIPS_BY_SOURCE.get(nodeType) || [];
+      relationshipCounts.set(nodeType, relationships.length);
+      for (const rel of relationships)
+        usedPredicatesSet.add(rel.predicate);
+    }
+    const relationshipCount = Array.from(relationshipCounts.values()).reduce((sum, count) => sum + count, 0), isolatedNodeTypes = nodeTypes.filter((type) => (relationshipCounts.get(type) || 0) === 0), isolationPercentage = createPercentage(nodeTypeCount > 0 ? isolatedNodeTypes.length / nodeTypeCount * 100 : 0), availablePredicates = await this.getAvailablePredicatesForLayer(layer.id), 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, standardAlignment = await this.analyzeStandardAlignment(layer);
+    return {
+      layer: layer.id,
+      nodeTypeCount,
+      relationshipCount,
+      interLayerRelationshipCount: 0,
+      isolatedNodeTypes,
+      isolationPercentage,
+      availablePredicates,
+      usedPredicates,
+      utilizationPercentage,
+      relationshipsPerNodeType,
+      standardAlignment
+    };
+  }
+  /**
+   * Get available predicates for a layer
+   */
+  async getAvailablePredicatesForLayer(layerId) {
+    return this.catalog.getTypesForLayer(layerId).map((rt) => rt.predicate);
+  }
+  /**
+   * Analyze standard alignment for ArchiMate layers
+   */
+  async analyzeStandardAlignment(layer) {
+    if (!layer.inspiredBy || layer.inspiredBy.standard !== "ArchiMate 3.2")
+      return;
+    const expectedPatterns = this.getArchimateExpectedPatterns(layer.id);
+    return {
+      standard: layer.inspiredBy.standard,
+      expectedRelationships: expectedPatterns.length,
+      missingFromStandard: expectedPatterns
+    };
+  }
+  /**
+   * Get expected ArchiMate relationship patterns for a layer
+   */
+  getArchimateExpectedPatterns(layerId) {
+    const template = LAYER_TEMPLATES.find((t) => t.layer === layerId);
+    return template ? template.patterns.map((p) => `${p.sourcePattern}\u2192${p.predicate}\u2192${p.destinationPattern}`) : [];
+  }
+}
+export {
+  CoverageAnalyzer
+};
+//# sourceMappingURL=coverage-analyzer.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/analysis/coverage-analyzer.ts"],
+  "sourcesContent": ["/**\n * Coverage Analyzer - Computes relationship coverage metrics\n *\n * Analyzes:\n * - Node isolation (node types with zero relationships)\n * - Predicate utilization (available vs. used predicates)\n * - Relationship density\n * - Standard alignment validation\n */\n\nimport { RelationshipCatalog } from \"../../../core/relationship-catalog.js\";\nimport { RELATIONSHIPS_BY_SOURCE } from \"../../../generated/relationship-index.js\";\nimport {\n  getAllLayers,\n  type LayerMetadata,\n} from \"../../../generated/layer-registry.js\";\nimport { LAYER_TEMPLATES } from \"./layer-templates.js\";\nimport type { CoverageMetrics } from \"../../types.js\";\nimport { createPercentage } from \"../../types.js\";\n\n/**\n * Result from coverage analysis indicating success/partial/failure status\n */\nexport interface CoverageAnalysisResult {\n  /** Metrics for successfully analyzed layers */\n  results: CoverageMetrics[];\n  /** Failures encountered during analysis (if any) */\n  failures: Array<{ layer: string; error: Error }>;\n  /** Whether analysis completed for all layers */\n  isComplete: boolean;\n}\n\n/**\n * Coverage analyzer for relationship metrics\n */\nexport class CoverageAnalyzer {\n  constructor(private catalog: RelationshipCatalog) {}\n\n  /**\n   * Analyze coverage for all layers\n   * @returns Result object indicating success/partial/failure with complete flag\n   */\n  async analyzeAll(): Promise<CoverageAnalysisResult> {\n    const layers = getAllLayers();\n    const results: CoverageMetrics[] = [];\n    const errors: Array<{ layer: string; error: Error }> = [];\n\n    for (const layer of layers) {\n      try {\n        const metrics = await this.analyzeLayer(layer);\n        results.push(metrics);\n      } catch (error) {\n        errors.push({\n          layer: layer.id,\n          error: error instanceof Error ? error : new Error(String(error)),\n        });\n      }\n    }\n\n    // If all layers failed, throw the first error\n    if (results.length === 0 && errors.length > 0) {\n      throw errors[0].error;\n    }\n\n    // Report partial failures to user\n    if (errors.length > 0 && results.length > 0) {\n      console.error(\n        `\\n\u26A0\uFE0F  Warning: Coverage analysis failed for ${errors.length} layer(s):`\n      );\n      for (const { layer, error } of errors) {\n        console.error(`  - ${layer}: ${error.message}`);\n      }\n      console.error(\n        `\\nSuccessfully analyzed ${results.length}/${layers.length} layers.\\n`\n      );\n    }\n\n    return {\n      results,\n      failures: errors,\n      isComplete: errors.length === 0,\n    };\n  }\n\n  /**\n   * Analyze coverage for a single layer\n   */\n  async analyzeLayer(layer: LayerMetadata): Promise<CoverageMetrics> {\n    const nodeTypes = layer.nodeTypes;\n    const nodeTypeCount = nodeTypes.length;\n\n    // Count relationships per node type\n    const relationshipCounts = new Map<string, number>();\n    const usedPredicatesSet = new Set<string>();\n\n    for (const nodeType of nodeTypes) {\n      const relationships = RELATIONSHIPS_BY_SOURCE.get(nodeType) || [];\n      relationshipCounts.set(nodeType, relationships.length);\n\n      // Track used predicates\n      for (const rel of relationships) {\n        usedPredicatesSet.add(rel.predicate);\n      }\n    }\n\n    // Calculate total relationships\n    const relationshipCount = Array.from(relationshipCounts.values()).reduce(\n      (sum, count) => sum + count,\n      0\n    );\n\n    // Identify isolated node types (zero relationships)\n    const isolatedNodeTypes = nodeTypes.filter(\n      (type) => (relationshipCounts.get(type) || 0) === 0\n    );\n    const isolationPercentage = createPercentage(\n      nodeTypeCount > 0 ? (isolatedNodeTypes.length / nodeTypeCount) * 100 : 0\n    );\n\n    // Get available predicates for this layer\n    const availablePredicates = await this.getAvailablePredicatesForLayer(\n      layer.id\n    );\n    // Filter used predicates to only include those defined in relationship schemas for this layer\n    // This handles cases where relationship index contains predicates not yet formalized in schemas\n    const availablePredicateSet = new Set(availablePredicates);\n    const usedPredicates = Array.from(usedPredicatesSet).filter(\n      (p) => availablePredicateSet.has(p)\n    );\n    const utilizationPercentage = createPercentage(\n      availablePredicates.length > 0\n        ? (usedPredicates.length / availablePredicates.length) * 100\n        : 0\n    );\n\n    // Calculate density\n    const relationshipsPerNodeType =\n      nodeTypeCount > 0 ? relationshipCount / nodeTypeCount : 0;\n\n    // Standard alignment (for ArchiMate layers)\n    const standardAlignment = await this.analyzeStandardAlignment(layer);\n\n    return {\n      layer: layer.id,\n      nodeTypeCount,\n      relationshipCount,\n      interLayerRelationshipCount: 0,\n      isolatedNodeTypes,\n      isolationPercentage,\n      availablePredicates,\n      usedPredicates,\n      utilizationPercentage,\n      relationshipsPerNodeType,\n      standardAlignment,\n    };\n  }\n\n  /**\n   * Get available predicates for a layer\n   */\n  private async getAvailablePredicatesForLayer(\n    layerId: string\n  ): Promise<string[]> {\n    const relationshipTypes = this.catalog.getTypesForLayer(layerId);\n    return relationshipTypes.map((rt) => rt.predicate);\n  }\n\n  /**\n   * Analyze standard alignment for ArchiMate layers\n   */\n  private async analyzeStandardAlignment(\n    layer: LayerMetadata\n  ): Promise<CoverageMetrics[\"standardAlignment\"] | undefined> {\n    if (!layer.inspiredBy) {\n      return undefined;\n    }\n\n    // Check if this is an ArchiMate layer\n    if (layer.inspiredBy.standard !== \"ArchiMate 3.2\") {\n      return undefined;\n    }\n\n    // ArchiMate 3.2 expected relationship patterns\n    const expectedPatterns = this.getArchimateExpectedPatterns(layer.id);\n\n    return {\n      standard: layer.inspiredBy.standard,\n      expectedRelationships: expectedPatterns.length,\n      missingFromStandard: expectedPatterns,\n    };\n  }\n\n  /**\n   * Get expected ArchiMate relationship patterns for a layer\n   */\n  private getArchimateExpectedPatterns(layerId: string): string[] {\n    const template = LAYER_TEMPLATES.find((t) => t.layer === layerId);\n    if (!template) {\n      return [];\n    }\n\n    return template.patterns.map(\n      (p) => `${p.sourcePattern}\u2192${p.predicate}\u2192${p.destinationPattern}`\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,95 @@
+import { RELATIONSHIPS } from "../../../generated/relationship-index.js";
+import { duplicateImpactScore } from "../../types.js";
+class DuplicateDetector {
+  catalog;
+  duplicateCache = null;
+  constructor(catalog) {
+    this.catalog = catalog;
+  }
+  /**
+   * Detect all duplicate candidates
+   */
+  detectDuplicates() {
+    if (this.duplicateCache !== null)
+      return this.duplicateCache;
+    const candidates = [], relationshipsByEndpoints = /* @__PURE__ */ new Map();
+    for (const rel of RELATIONSHIPS) {
+      const key = `${rel.sourceSpecNodeId}:${rel.destinationSpecNodeId}`, group = relationshipsByEndpoints.get(key) || [];
+      group.push(rel), relationshipsByEndpoints.set(key, group);
+    }
+    for (const [_, group] of relationshipsByEndpoints)
+      if (!(group.length < 2))
+        for (let i = 0; i < group.length; i++)
+          for (let j = i + 1; j < group.length; j++) {
+            const candidate = this.checkDuplicatePair(group[i], group[j]);
+            candidate && candidates.push(candidate);
+          }
+    return this.duplicateCache = candidates, candidates;
+  }
+  /**
+   * Check if two relationships are semantic duplicates
+   */
+  checkDuplicatePair(rel1, rel2) {
+    const pred1 = this.catalog.getTypeByPredicate(rel1.predicate), pred2 = this.catalog.getTypeByPredicate(rel2.predicate);
+    if (!pred1 || !pred2)
+      return pred1 || console.warn(`[DuplicateDetector] Unknown predicate not found in catalog: ${rel1.predicate} (relationship: ${rel1.id})`), pred2 || console.warn(`[DuplicateDetector] Unknown predicate not found in catalog: ${rel2.predicate} (relationship: ${rel2.id})`), null;
+    if (pred1.category === pred2.category) {
+      const confidence = this.assessConfidence(pred1, pred2), reason = this.buildReason(pred1, pred2), impactScore = duplicateImpactScore(confidence);
+      return {
+        relationships: [rel1.id, rel2.id],
+        predicates: [rel1.predicate, rel2.predicate],
+        sourceNodeType: rel1.sourceSpecNodeId,
+        destinationNodeType: rel1.destinationSpecNodeId,
+        reason,
+        confidence,
+        impactScore,
+        alignmentScore: 100 - impactScore
+      };
+    }
+    if (pred1.inversePredicate === pred2.predicate || pred2.inversePredicate === pred1.predicate) {
+      const impactScore = duplicateImpactScore("high");
+      return {
+        relationships: [rel1.id, rel2.id],
+        predicates: [rel1.predicate, rel2.predicate],
+        sourceNodeType: rel1.sourceSpecNodeId,
+        destinationNodeType: rel1.destinationSpecNodeId,
+        reason: "Predicates are inverses of each other",
+        confidence: "high",
+        impactScore,
+        alignmentScore: 100 - impactScore
+      };
+    }
+    return null;
+  }
+  /**
+   * Assess confidence level of duplicate detection
+   */
+  assessConfidence(pred1, pred2) {
+    return !pred1 || !pred2 ? "low" : pred1.category === pred2.category && pred1.semantics.transitivity === pred2.semantics.transitivity && pred1.semantics.symmetry === pred2.semantics.symmetry ? "high" : pred1.category === pred2.category ? "medium" : "low";
+  }
+  /**
+   * Build reason explanation for duplicate detection
+   */
+  buildReason(pred1, pred2) {
+    if (!pred1 || !pred2)
+      return "Unknown";
+    const parts = [];
+    return pred1.category === pred2.category && parts.push(`Both predicates in "${pred1.category}" category`), pred1.semantics.transitivity && pred2.semantics.transitivity && parts.push("both transitive"), pred1.semantics.symmetry && pred2.semantics.symmetry && parts.push("both symmetric"), parts.join(", ");
+  }
+  /**
+   * Get duplicate candidates by layer
+   */
+  detectDuplicatesByLayer(layerId) {
+    return this.detectDuplicates().filter((d) => d.sourceNodeType.startsWith(`${layerId}.`));
+  }
+  /**
+   * Get duplicate candidates by confidence level
+   */
+  detectDuplicatesByConfidence(confidence) {
+    return this.detectDuplicates().filter((d) => d.confidence === confidence);
+  }
+}
+export {
+  DuplicateDetector
+};
+//# sourceMappingURL=duplicate-detector.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/analysis/duplicate-detector.ts"],
+  "sourcesContent": ["/**\n * Duplicate Detector - Identifies semantic duplicate relationships\n *\n * Detects relationships where multiple predicates express the same\n * architectural meaning using:\n * - Predicate category analysis\n * - Transitivity/symmetry semantics\n * - Source/destination endpoint matching\n */\n\nimport { RelationshipCatalog } from \"../../../core/relationship-catalog.js\";\nimport {\n  RELATIONSHIPS,\n  type RelationshipSpec,\n} from \"../../../generated/relationship-index.js\";\nimport { duplicateImpactScore, type DuplicateCandidate } from \"../../types.js\";\n\n/**\n * Duplicate detector for semantic relationship overlap\n */\nexport class DuplicateDetector {\n  private duplicateCache: DuplicateCandidate[] | null = null;\n\n  constructor(private catalog: RelationshipCatalog) {}\n\n  /**\n   * Detect all duplicate candidates\n   */\n  detectDuplicates(): DuplicateCandidate[] {\n    // Return cached results if available\n    if (this.duplicateCache !== null) {\n      return this.duplicateCache;\n    }\n    const candidates: DuplicateCandidate[] = [];\n    const relationshipsByEndpoints = new Map<\n      string,\n      RelationshipSpec[]\n    >();\n\n    // Group relationships by source+destination\n    for (const rel of RELATIONSHIPS) {\n      const key = `${rel.sourceSpecNodeId}:${rel.destinationSpecNodeId}`;\n      const group = relationshipsByEndpoints.get(key) || [];\n      group.push(rel);\n      relationshipsByEndpoints.set(key, group);\n    }\n\n    // Check for predicate overlap within same endpoints\n    for (const [_, group] of relationshipsByEndpoints) {\n      if (group.length < 2) {\n        continue;\n      }\n\n      // Check all pairs within the group\n      for (let i = 0; i < group.length; i++) {\n        for (let j = i + 1; j < group.length; j++) {\n          const candidate = this.checkDuplicatePair(group[i], group[j]);\n          if (candidate) {\n            candidates.push(candidate);\n          }\n        }\n      }\n    }\n\n    // Cache the results\n    this.duplicateCache = candidates;\n\n    return candidates;\n  }\n\n  /**\n   * Check if two relationships are semantic duplicates\n   */\n  private checkDuplicatePair(\n    rel1: RelationshipSpec,\n    rel2: RelationshipSpec\n  ): DuplicateCandidate | null {\n    const pred1 = this.catalog.getTypeByPredicate(rel1.predicate);\n    const pred2 = this.catalog.getTypeByPredicate(rel2.predicate);\n\n    if (!pred1 || !pred2) {\n      // Log unknown predicates for debugging\n      if (!pred1) {\n        console.warn(\n          `[DuplicateDetector] Unknown predicate not found in catalog: ${rel1.predicate} (relationship: ${rel1.id})`\n        );\n      }\n      if (!pred2) {\n        console.warn(\n          `[DuplicateDetector] Unknown predicate not found in catalog: ${rel2.predicate} (relationship: ${rel2.id})`\n        );\n      }\n      return null;\n    }\n\n    // Check if predicates are in the same category\n    if (pred1.category === pred2.category) {\n      const confidence = this.assessConfidence(pred1, pred2);\n      const reason = this.buildReason(pred1, pred2);\n      const impactScore = duplicateImpactScore(confidence);\n\n      return {\n        relationships: [rel1.id, rel2.id],\n        predicates: [rel1.predicate, rel2.predicate],\n        sourceNodeType: rel1.sourceSpecNodeId,\n        destinationNodeType: rel1.destinationSpecNodeId,\n        reason,\n        confidence,\n        impactScore,\n        alignmentScore: 100 - impactScore,\n      };\n    }\n\n    // Check for inverse relationships (may indicate redundancy)\n    if (\n      pred1.inversePredicate === pred2.predicate ||\n      pred2.inversePredicate === pred1.predicate\n    ) {\n      const impactScore = duplicateImpactScore(\"high\");\n      return {\n        relationships: [rel1.id, rel2.id],\n        predicates: [rel1.predicate, rel2.predicate],\n        sourceNodeType: rel1.sourceSpecNodeId,\n        destinationNodeType: rel1.destinationSpecNodeId,\n        reason: \"Predicates are inverses of each other\",\n        confidence: \"high\",\n        impactScore,\n        alignmentScore: 100 - impactScore,\n      };\n    }\n\n    return null;\n  }\n\n  /**\n   * Assess confidence level of duplicate detection\n   */\n  private assessConfidence(\n    pred1: ReturnType<RelationshipCatalog[\"getTypeByPredicate\"]>,\n    pred2: ReturnType<RelationshipCatalog[\"getTypeByPredicate\"]>\n  ): \"high\" | \"medium\" | \"low\" {\n    if (!pred1 || !pred2) {\n      return \"low\";\n    }\n\n    // High confidence: same category + same semantics\n    if (\n      pred1.category === pred2.category &&\n      pred1.semantics.transitivity === pred2.semantics.transitivity &&\n      pred1.semantics.symmetry === pred2.semantics.symmetry\n    ) {\n      return \"high\";\n    }\n\n    // Medium confidence: same category + different semantics\n    if (pred1.category === pred2.category) {\n      return \"medium\";\n    }\n\n    return \"low\";\n  }\n\n  /**\n   * Build reason explanation for duplicate detection\n   */\n  private buildReason(\n    pred1: ReturnType<RelationshipCatalog[\"getTypeByPredicate\"]>,\n    pred2: ReturnType<RelationshipCatalog[\"getTypeByPredicate\"]>\n  ): string {\n    if (!pred1 || !pred2) {\n      return \"Unknown\";\n    }\n\n    const parts: string[] = [];\n\n    // Category overlap\n    if (pred1.category === pred2.category) {\n      parts.push(`Both predicates in \"${pred1.category}\" category`);\n    }\n\n    // Semantic overlap\n    if (pred1.semantics.transitivity && pred2.semantics.transitivity) {\n      parts.push(\"both transitive\");\n    }\n    if (pred1.semantics.symmetry && pred2.semantics.symmetry) {\n      parts.push(\"both symmetric\");\n    }\n\n    return parts.join(\", \");\n  }\n\n  /**\n   * Get duplicate candidates by layer\n   */\n  detectDuplicatesByLayer(layerId: string): DuplicateCandidate[] {\n    const allDuplicates = this.detectDuplicates();\n    return allDuplicates.filter((d) =>\n      d.sourceNodeType.startsWith(`${layerId}.`)\n    );\n  }\n\n  /**\n   * Get duplicate candidates by confidence level\n   */\n  detectDuplicatesByConfidence(\n    confidence: \"high\" | \"medium\" | \"low\"\n  ): DuplicateCandidate[] {\n    const allDuplicates = this.detectDuplicates();\n    return allDuplicates.filter((d) => d.confidence === confidence);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,99 @@
+import { RELATIONSHIPS_BY_SOURCE } from "../../../generated/relationship-index.js";
+import { getAllLayers } from "../../../generated/layer-registry.js";
+import { LAYER_TEMPLATES } from "./layer-templates.js";
+import { gapImpactScore } from "../../types.js";
+class GapAnalyzer {
+  /**
+   * Analyze gaps for all layers
+   */
+  analyzeAll() {
+    const layers = getAllLayers(), candidates = [];
+    for (const layer of layers) {
+      const layerGaps = this.analyzeLayer(layer);
+      candidates.push(...layerGaps);
+    }
+    return candidates;
+  }
+  /**
+   * Analyze gaps for a single layer with analysis status
+   */
+  analyzeLayerWithStatus(layer) {
+    const patterns = this.getLayerTemplates(layer);
+    if (patterns.length === 0)
+      return {
+        analyzed: !1,
+        gaps: [],
+        reason: `No template available for layer '${layer.id}'`
+      };
+    const candidates = [];
+    for (const pattern of patterns) {
+      const sourceTypes = this.findMatchingNodeTypes(layer, pattern.sourceType), destinationTypes = this.findMatchingNodeTypes(layer, pattern.destinationType);
+      for (const sourceType of sourceTypes)
+        for (const destType of destinationTypes)
+          if (!this.relationshipExists(sourceType, destType, pattern.predicate)) {
+            const priority = this.assessPriority(layer, sourceType), impactScore = gapImpactScore(priority);
+            candidates.push({
+              sourceNodeType: sourceType,
+              destinationNodeType: destType,
+              suggestedPredicate: pattern.predicate,
+              reason: pattern.reason,
+              priority,
+              standardReference: pattern.standardReference,
+              impactScore,
+              alignmentScore: 100 - impactScore
+            });
+          }
+    }
+    return {
+      analyzed: !0,
+      gaps: candidates
+    };
+  }
+  /**
+   * Analyze gaps for a single layer (legacy method for backward compatibility)
+   */
+  analyzeLayer(layer) {
+    return this.analyzeLayerWithStatus(layer).gaps;
+  }
+  /**
+   * Get relationship templates for a layer
+   */
+  getLayerTemplates(layer) {
+    const template = LAYER_TEMPLATES.find((t) => t.layer === layer.id);
+    return template ? template.patterns.map((p) => ({
+      sourceType: p.sourcePattern,
+      destinationType: p.destinationPattern,
+      predicate: p.predicate,
+      reason: p.description,
+      standardReference: `${template.standard}`
+    })) : [];
+  }
+  /**
+   * Find node types matching a pattern
+   */
+  findMatchingNodeTypes(layer, pattern) {
+    return layer.nodeTypes.filter((nodeType) => {
+      const typeName = nodeType.split(".")[1];
+      return typeName?.includes(pattern) || typeName === pattern;
+    });
+  }
+  /**
+   * Check if a relationship exists
+   */
+  relationshipExists(sourceType, destType, predicate) {
+    return (RELATIONSHIPS_BY_SOURCE.get(sourceType) || []).some((rel) => rel.destinationSpecNodeId === destType && rel.predicate === predicate);
+  }
+  /**
+   * Assess priority of a gap
+   */
+  assessPriority(layer, sourceType) {
+    if (["security", "ux", "navigation"].includes(layer.id))
+      return "high";
+    const typeName = sourceType.split(".")[1] || "";
+    return typeName.includes("component") || typeName.includes("container") || typeName.includes("service") || typeName.includes("module") ? "medium" : "low";
+  }
+}
+export {
+  GapAnalyzer
+};
+//# sourceMappingURL=gap-analyzer.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/relationships/analysis/gap-analyzer.ts"],
+  "sourcesContent": ["/**\n * Gap Analyzer - Identifies missing relationships based on layer-specific templates\n *\n * Uses standard-inspired templates to identify missing architectural\n * relationships that should exist based on:\n * - ArchiMate 3.2 metamodel patterns (layers 1, 2, 4, 5)\n * - OpenAPI 3.0 operation patterns (layer 6)\n * - NIST SP 800-53 control framework patterns (layer 3)\n * - React and router component patterns (layers 9, 10)\n *\n * Note: Gap detection is heuristic-based and patterns are inspired by these standards\n * and frameworks, not formally compliant implementations of them.\n */\n\nimport { RELATIONSHIPS_BY_SOURCE } from \"../../../generated/relationship-index.js\";\nimport {\n  getAllLayers,\n  type LayerMetadata,\n} from \"../../../generated/layer-registry.js\";\nimport { LAYER_TEMPLATES } from \"./layer-templates.js\";\nimport { gapImpactScore, type GapCandidate } from \"../../types.js\";\n\n/**\n * Expected relationship pattern template\n */\ninterface RelationshipPattern {\n  sourceType: string; // Node type pattern (e.g., \"goal\", \"process\")\n  destinationType: string;\n  predicate: string;\n  reason: string;\n  standardReference?: string;\n}\n\n/**\n * Gap analysis result with analysis status\n */\nexport interface GapAnalysisResult {\n  analyzed: boolean; // Whether the layer was analyzed\n  gaps: GapCandidate[]; // Gap candidates (empty array if analyzed with no gaps, or if not analyzed)\n  reason?: string; // Reason for not analyzing (e.g., \"No template available for layer\")\n}\n\n/**\n * Gap analyzer for missing relationships\n */\nexport class GapAnalyzer {\n  /**\n   * Analyze gaps for all layers\n   */\n  analyzeAll(): GapCandidate[] {\n    const layers = getAllLayers();\n    const candidates: GapCandidate[] = [];\n\n    for (const layer of layers) {\n      const layerGaps = this.analyzeLayer(layer);\n      candidates.push(...layerGaps);\n    }\n\n    return candidates;\n  }\n\n  /**\n   * Analyze gaps for a single layer with analysis status\n   */\n  analyzeLayerWithStatus(layer: LayerMetadata): GapAnalysisResult {\n    const patterns = this.getLayerTemplates(layer);\n\n    // Check if layer has templates\n    if (patterns.length === 0) {\n      return {\n        analyzed: false,\n        gaps: [],\n        reason: `No template available for layer '${layer.id}'`,\n      };\n    }\n\n    const candidates: GapCandidate[] = [];\n\n    for (const pattern of patterns) {\n      // Find matching node types\n      const sourceTypes = this.findMatchingNodeTypes(\n        layer,\n        pattern.sourceType\n      );\n      const destinationTypes = this.findMatchingNodeTypes(\n        layer,\n        pattern.destinationType\n      );\n\n      // Check for missing relationships\n      for (const sourceType of sourceTypes) {\n        for (const destType of destinationTypes) {\n          const exists = this.relationshipExists(\n            sourceType,\n            destType,\n            pattern.predicate\n          );\n\n          if (!exists) {\n            const priority = this.assessPriority(layer, sourceType);\n            const impactScore = gapImpactScore(priority);\n            candidates.push({\n              sourceNodeType: sourceType,\n              destinationNodeType: destType,\n              suggestedPredicate: pattern.predicate,\n              reason: pattern.reason,\n              priority,\n              standardReference: pattern.standardReference,\n              impactScore,\n              alignmentScore: 100 - impactScore,\n            });\n          }\n        }\n      }\n    }\n\n    return {\n      analyzed: true,\n      gaps: candidates,\n    };\n  }\n\n  /**\n   * Analyze gaps for a single layer (legacy method for backward compatibility)\n   */\n  analyzeLayer(layer: LayerMetadata): GapCandidate[] {\n    const result = this.analyzeLayerWithStatus(layer);\n    return result.gaps;\n  }\n\n  /**\n   * Get relationship templates for a layer\n   */\n  private getLayerTemplates(layer: LayerMetadata): RelationshipPattern[] {\n    const template = LAYER_TEMPLATES.find((t) => t.layer === layer.id);\n    if (!template) {\n      return [];\n    }\n\n    return template.patterns.map((p) => ({\n      sourceType: p.sourcePattern,\n      destinationType: p.destinationPattern,\n      predicate: p.predicate,\n      reason: p.description,\n      standardReference: `${template.standard}`,\n    }));\n  }\n\n  /**\n   * Find node types matching a pattern\n   */\n  private findMatchingNodeTypes(\n    layer: LayerMetadata,\n    pattern: string\n  ): string[] {\n    return layer.nodeTypes.filter((nodeType) => {\n      const typeName = nodeType.split(\".\")[1];\n      return typeName?.includes(pattern) || typeName === pattern;\n    });\n  }\n\n  /**\n   * Check if a relationship exists\n   */\n  private relationshipExists(\n    sourceType: string,\n    destType: string,\n    predicate: string\n  ): boolean {\n    const relationships = RELATIONSHIPS_BY_SOURCE.get(sourceType) || [];\n    return relationships.some(\n      (rel) =>\n        rel.destinationSpecNodeId === destType && rel.predicate === predicate\n    );\n  }\n\n  /**\n   * Assess priority of a gap\n   */\n  private assessPriority(\n    layer: LayerMetadata,\n    sourceType: string\n  ): \"high\" | \"medium\" | \"low\" {\n    // High priority: zero-relationship layers\n    if ([\"security\", \"ux\", \"navigation\"].includes(layer.id)) {\n      return \"high\";\n    }\n\n    // Medium priority: container/composition types\n    const typeName = sourceType.split(\".\")[1] || \"\";\n    if (\n      typeName.includes(\"component\") ||\n      typeName.includes(\"container\") ||\n      typeName.includes(\"service\") ||\n      typeName.includes(\"module\")\n    ) {\n      return \"medium\";\n    }\n\n    // Low priority: all other patterns\n    return \"low\";\n  }\n}\n"],
+  "mappings": "AAcA,SAAS,+BAA+B;AACxC,SACE,oBAEK;AACP,SAAS,uBAAuB;AAChC,SAAS,sBAAyC;AAyB5C,MAAO,YAAW;;;;EAItB,aAAU;AACR,UAAM,SAAS,aAAY,GACrB,aAA6B,CAAA;AAEnC,eAAW,SAAS,QAAQ;AAC1B,YAAM,YAAY,KAAK,aAAa,KAAK;AACzC,iBAAW,KAAK,GAAG,SAAS;IAC9B;AAEA,WAAO;EACT;;;;EAKA,uBAAuB,OAAoB;AACzC,UAAM,WAAW,KAAK,kBAAkB,KAAK;AAG7C,QAAI,SAAS,WAAW;AACtB,aAAO;QACL,UAAU;QACV,MAAM,CAAA;QACN,QAAQ,oCAAoC,MAAM,EAAE;;AAIxD,UAAM,aAA6B,CAAA;AAEnC,eAAW,WAAW,UAAU;AAE9B,YAAM,cAAc,KAAK,sBACvB,OACA,QAAQ,UAAU,GAEd,mBAAmB,KAAK,sBAC5B,OACA,QAAQ,eAAe;AAIzB,iBAAW,cAAc;AACvB,mBAAW,YAAY;AAOrB,cAAI,CANW,KAAK,mBAClB,YACA,UACA,QAAQ,SAAS,GAGN;AACX,kBAAM,WAAW,KAAK,eAAe,OAAO,UAAU,GAChD,cAAc,eAAe,QAAQ;AAC3C,uBAAW,KAAK;cACd,gBAAgB;cAChB,qBAAqB;cACrB,oBAAoB,QAAQ;cAC5B,QAAQ,QAAQ;cAChB;cACA,mBAAmB,QAAQ;cAC3B;cACA,gBAAgB,MAAM;aACvB;UACH;IAGN;AAEA,WAAO;MACL,UAAU;MACV,MAAM;;EAEV;;;;EAKA,aAAa,OAAoB;AAE/B,WADe,KAAK,uBAAuB,KAAK,EAClC;EAChB;;;;EAKQ,kBAAkB,OAAoB;AAC5C,UAAM,WAAW,gBAAgB,KAAK,CAAC,MAAM,EAAE,UAAU,MAAM,EAAE;AACjE,WAAK,WAIE,SAAS,SAAS,IAAI,CAAC,OAAO;MACnC,YAAY,EAAE;MACd,iBAAiB,EAAE;MACnB,WAAW,EAAE;MACb,QAAQ,EAAE;MACV,mBAAmB,GAAG,SAAS,QAAQ;MACvC,IATO,CAAA;EAUX;;;;EAKQ,sBACN,OACA,SAAe;AAEf,WAAO,MAAM,UAAU,OAAO,CAAC,aAAY;AACzC,YAAM,WAAW,SAAS,MAAM,GAAG,EAAE,CAAC;AACtC,aAAO,UAAU,SAAS,OAAO,KAAK,aAAa;IACrD,CAAC;EACH;;;;EAKQ,mBACN,YACA,UACA,WAAiB;AAGjB,YADsB,wBAAwB,IAAI,UAAU,KAAK,CAAA,GAC5C,KACnB,CAAC,QACC,IAAI,0BAA0B,YAAY,IAAI,cAAc,SAAS;EAE3E;;;;EAKQ,eACN,OACA,YAAkB;AAGlB,QAAI,CAAC,YAAY,MAAM,YAAY,EAAE,SAAS,MAAM,EAAE;AACpD,aAAO;AAIT,UAAM,WAAW,WAAW,MAAM,GAAG,EAAE,CAAC,KAAK;AAC7C,WACE,SAAS,SAAS,WAAW,KAC7B,SAAS,SAAS,WAAW,KAC7B,SAAS,SAAS,SAAS,KAC3B,SAAS,SAAS,QAAQ,IAEnB,WAIF;EACT;;",
+  "names": []
+}