@documentation-robotics/cli 0.1.0 → 0.1.7

package/dist/analysis/data-model-analyzer.js

@@ -0,0 +1,189 @@
+class DataModelAnalyzer {
+  model;
+  constructor(model) {
+    this.model = model;
+  }
+  /**
+   * Analyze entities in the data model layer
+   */
+  async analyzeEntities() {
+    const dataModelLayer = await this.model.getLayer("data-model"), entities = [];
+    if (!dataModelLayer)
+      return entities;
+    const referencesFrom = /* @__PURE__ */ new Set();
+    for (const layerName of this.model.getLayerNames()) {
+      if (layerName === "data-model")
+        continue;
+      const layer = await this.model.getLayer(layerName);
+      if (layer) {
+        for (const element of layer.listElements())
+          if (element.references)
+            for (const ref of element.references)
+              ref.target.startsWith("data-model.") && referencesFrom.add(ref.target);
+      }
+    }
+    for (const element of dataModelLayer.listElements()) {
+      const attributes = element.attributes ? Object.keys(element.attributes) : [], relationships = element.relationships ? element.relationships : [];
+      entities.push({
+        id: element.path || element.id || "",
+        name: element.name,
+        layer: "data-model",
+        attributes,
+        relatedEntities: relationships.map((r) => r.target),
+        isReferenced: referencesFrom.has(element.path || element.id || "")
+      });
+    }
+    return entities;
+  }
+  /**
+   * Check constraints for data model entities
+   */
+  async checkConstraints() {
+    const dataModelLayer = await this.model.getLayer("data-model"), constraints = [];
+    if (!dataModelLayer)
+      return constraints;
+    for (const element of dataModelLayer.listElements())
+      (!element.attributes || Object.keys(element.attributes).length === 0) && constraints.push({
+        entityId: element.path || element.id || "",
+        constraintType: "not-null",
+        description: "Entity has no attributes defined",
+        isValid: !1
+      }), (!element.description || element.description.length === 0) && constraints.push({
+        entityId: element.path || element.id || "",
+        constraintType: "check",
+        description: "Entity has no description",
+        isValid: !1
+      });
+    return constraints;
+  }
+  /**
+   * Analyze cardinality of relationships
+   */
+  async checkCardinality() {
+    const dataModelLayer = await this.model.getLayer("data-model"), cardinalities = [];
+    if (!dataModelLayer)
+      return cardinalities;
+    for (const element of dataModelLayer.listElements())
+      if (element.relationships)
+        for (const rel of element.relationships) {
+          let cardinality = "one-to-many";
+          rel.predicate.includes("one-to-one") || rel.predicate === "has-one" ? cardinality = "one-to-one" : (rel.predicate.includes("many-to-many") || rel.predicate === "has-many-to-many") && (cardinality = "many-to-many"), cardinalities.push({
+            sourceEntity: element.path || element.id || "",
+            targetEntity: rel.target,
+            cardinality,
+            isOptional: rel.properties?.optional === !0 || !1
+          });
+        }
+    return cardinalities;
+  }
+  /**
+   * Find data quality issues
+   */
+  async identifyIssues() {
+    const issues = [], entities = await this.analyzeEntities(), constraints = await this.checkConstraints();
+    for (const constraint of constraints)
+      constraint.isValid || issues.push({
+        type: constraint.constraintType === "not-null" ? "incomplete" : "missing-constraint",
+        entityId: constraint.entityId,
+        description: constraint.description,
+        severity: "medium"
+      });
+    for (const entity of entities)
+      !entity.isReferenced && entity.relatedEntities.length === 0 && issues.push({
+        type: "orphaned",
+        entityId: entity.id,
+        description: `Entity "${entity.name}" is not referenced and has no relationships`,
+        severity: "low"
+      });
+    return issues;
+  }
+  /**
+   * Calculate coverage metrics
+   */
+  async calculateCoverage() {
+    const entities = await this.analyzeEntities();
+    let documentsCount = 0, constraintCount = 0, referencedCount = 0, orphanedCount = 0;
+    for (const entity of entities)
+      entity.attributes && entity.attributes.length > 0 && documentsCount++, entity.isReferenced && referencedCount++, !entity.isReferenced && entity.relatedEntities.length === 0 && orphanedCount++, entity.attributes && entity.attributes.length > 0 && constraintCount++;
+    const totalEntities = entities.length;
+    return {
+      totalEntities,
+      entitiesWithAttributes: documentsCount,
+      constraintsEntities: constraintCount,
+      referencedEntities: referencedCount,
+      orphanedEntities: orphanedCount,
+      attributeCoverage: totalEntities > 0 ? Math.round(documentsCount / totalEntities * 100) : 0,
+      constraintCoverage: totalEntities > 0 ? Math.round(constraintCount / totalEntities * 100) : 0,
+      referenceCoverage: totalEntities > 0 ? Math.round(referencedCount / totalEntities * 100) : 0
+    };
+  }
+  /**
+   * Calculate complexity metrics
+   */
+  async calculateComplexity() {
+    const entities = await this.analyzeEntities();
+    if (entities.length === 0)
+      return {
+        avgAttributesPerEntity: 0,
+        maxAttributesPerEntity: 0,
+        minAttributesPerEntity: 0,
+        avgRelationshipsPerEntity: 0,
+        maxRelationshipsPerEntity: 0,
+        entityDensity: 0
+      };
+    let totalAttributes = 0, maxAttributes = 0, minAttributes = 1 / 0, totalRelationships = 0, maxRelationships = 0;
+    for (const entity of entities) {
+      const attrCount = entity.attributes.length, relCount = entity.relatedEntities.length;
+      totalAttributes += attrCount, totalRelationships += relCount, maxAttributes = Math.max(maxAttributes, attrCount), minAttributes = Math.min(minAttributes, attrCount), maxRelationships = Math.max(maxRelationships, relCount);
+    }
+    const avgAttributes = totalAttributes / entities.length, avgRelationships = totalRelationships / entities.length, density = entities.length > 0 ? totalRelationships / (entities.length * entities.length) : 0;
+    return {
+      avgAttributesPerEntity: Math.round(avgAttributes * 10) / 10,
+      maxAttributesPerEntity: maxAttributes,
+      minAttributesPerEntity: minAttributes === 1 / 0 ? 0 : minAttributes,
+      avgRelationshipsPerEntity: Math.round(avgRelationships * 10) / 10,
+      maxRelationshipsPerEntity: maxRelationships,
+      entityDensity: Math.round(density * 1e4) / 1e4
+    };
+  }
+  /**
+   * Get entity dependency graph
+   */
+  async getEntityDependencyGraph() {
+    const entities = await this.analyzeEntities(), graph = /* @__PURE__ */ new Map();
+    for (const entity of entities) {
+      graph.has(entity.id) || graph.set(entity.id, /* @__PURE__ */ new Set());
+      for (const relatedId of entity.relatedEntities)
+        graph.get(entity.id).add(relatedId);
+    }
+    return graph;
+  }
+  /**
+   * Find entity clusters based on relationships
+   */
+  async findClusters() {
+    const graph = await this.getEntityDependencyGraph(), visited = /* @__PURE__ */ new Set(), clusters = [];
+    for (const nodeId of graph.keys())
+      if (!visited.has(nodeId)) {
+        const cluster = /* @__PURE__ */ new Set();
+        this.dfsCluster(nodeId, graph, visited, cluster), clusters.push(cluster);
+      }
+    return clusters;
+  }
+  /**
+   * DFS to find connected components (clusters)
+   */
+  dfsCluster(nodeId, graph, visited, cluster) {
+    if (visited.has(nodeId))
+      return;
+    visited.add(nodeId), cluster.add(nodeId);
+    const neighbors = graph.get(nodeId);
+    if (neighbors)
+      for (const neighbor of neighbors)
+        this.dfsCluster(neighbor, graph, visited, cluster);
+  }
+}
+export {
+  DataModelAnalyzer
+};
+//# sourceMappingURL=data-model-analyzer.js.map

package/dist/analysis/data-model-analyzer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/analysis/data-model-analyzer.ts"],
+  "sourcesContent": ["/**\n * Data Model Analyzer - Layer 7 specific analysis\n *\n * Provides specialized analysis for the Data Model layer (Layer 7).\n * Analyzes entities, relationships, constraints, and data quality.\n */\n\nimport { Model } from \"../core/model.js\";\nimport { DataModelEntity } from \"../core/report-data-model.js\";\n\n/**\n * Entity constraint information\n */\nexport interface EntityConstraint {\n  entityId: string;\n  constraintType: \"primary-key\" | \"unique\" | \"not-null\" | \"foreign-key\" | \"check\";\n  description: string;\n  isValid: boolean;\n}\n\n/**\n * Cardinality information\n */\nexport interface CardinalityInfo {\n  sourceEntity: string;\n  targetEntity: string;\n  cardinality: \"one-to-one\" | \"one-to-many\" | \"many-to-many\";\n  isOptional: boolean;\n}\n\n/**\n * Data quality issue\n */\nexport interface DataQualityIssue {\n  type: \"incomplete\" | \"inconsistent\" | \"orphaned\" | \"invalid-reference\" | \"missing-constraint\";\n  entityId: string;\n  description: string;\n  severity: \"low\" | \"medium\" | \"high\";\n}\n\n/**\n * Entity relationship information\n */\nexport interface EntityRelationship {\n  source: string;\n  target: string;\n  cardinality: string;\n  type: string;\n}\n\n/**\n * Coverage metrics for data model\n */\nexport interface DataModelCoverageMetrics {\n  totalEntities: number;\n  entitiesWithAttributes: number;\n  constraintsEntities: number;\n  referencedEntities: number;\n  orphanedEntities: number;\n  attributeCoverage: number; // 0-100\n  constraintCoverage: number; // 0-100\n  referenceCoverage: number; // 0-100\n}\n\n/**\n * Data model complexity metrics\n */\nexport interface DataModelComplexityMetrics {\n  avgAttributesPerEntity: number;\n  maxAttributesPerEntity: number;\n  minAttributesPerEntity: number;\n  avgRelationshipsPerEntity: number;\n  maxRelationshipsPerEntity: number;\n  entityDensity: number; // Relationships per entity squared\n}\n\n/**\n * Data Model Analyzer\n */\nexport class DataModelAnalyzer {\n  constructor(private model: Model) {}\n\n  /**\n   * Analyze entities in the data model layer\n   */\n  async analyzeEntities(): Promise<DataModelEntity[]> {\n    const dataModelLayer = await this.model.getLayer(\"data-model\");\n    const entities: DataModelEntity[] = [];\n\n    if (!dataModelLayer) {\n      return entities;\n    }\n\n    // Get all references to data model entities from other layers\n    const referencesFrom = new Set<string>();\n    for (const layerName of this.model.getLayerNames()) {\n      if (layerName === \"data-model\") continue;\n      const layer = await this.model.getLayer(layerName);\n      if (!layer) continue;\n\n      for (const element of layer.listElements()) {\n        if (element.references) {\n          for (const ref of element.references) {\n            if (ref.target.startsWith(\"data-model.\")) {\n              referencesFrom.add(ref.target);\n            }\n          }\n        }\n      }\n    }\n\n    // Analyze each entity\n    for (const element of dataModelLayer.listElements()) {\n      const attributes = element.attributes ? Object.keys(element.attributes) : [];\n      const relationships = element.relationships ? element.relationships : [];\n\n      entities.push({\n        id: element.path || element.id || \"\",\n        name: element.name,\n        layer: \"data-model\",\n        attributes,\n        relatedEntities: relationships.map((r) => r.target),\n        isReferenced: referencesFrom.has(element.path || element.id || \"\"),\n      });\n    }\n\n    return entities;\n  }\n\n  /**\n   * Check constraints for data model entities\n   */\n  async checkConstraints(): Promise<EntityConstraint[]> {\n    const dataModelLayer = await this.model.getLayer(\"data-model\");\n    const constraints: EntityConstraint[] = [];\n\n    if (!dataModelLayer) {\n      return constraints;\n    }\n\n    for (const element of dataModelLayer.listElements()) {\n      // Check if element has attributes\n      if (!element.attributes || Object.keys(element.attributes).length === 0) {\n        constraints.push({\n          entityId: element.path || element.id || \"\",\n          constraintType: \"not-null\",\n          description: \"Entity has no attributes defined\",\n          isValid: false,\n        });\n      }\n\n      // Check if entity is documented\n      if (!element.description || element.description.length === 0) {\n        constraints.push({\n          entityId: element.path || element.id || \"\",\n          constraintType: \"check\",\n          description: \"Entity has no description\",\n          isValid: false,\n        });\n      }\n    }\n\n    return constraints;\n  }\n\n  /**\n   * Analyze cardinality of relationships\n   */\n  async checkCardinality(): Promise<CardinalityInfo[]> {\n    const dataModelLayer = await this.model.getLayer(\"data-model\");\n    const cardinalities: CardinalityInfo[] = [];\n\n    if (!dataModelLayer) {\n      return cardinalities;\n    }\n\n    for (const element of dataModelLayer.listElements()) {\n      if (!element.relationships) continue;\n\n      for (const rel of element.relationships) {\n        // Infer cardinality from relationship properties or attributes\n        let cardinality: \"one-to-one\" | \"one-to-many\" | \"many-to-many\" = \"one-to-many\";\n\n        // Simple heuristic: if predicate contains \"many\", it's many-to-many or one-to-many\n        if (rel.predicate.includes(\"one-to-one\") || rel.predicate === \"has-one\") {\n          cardinality = \"one-to-one\";\n        } else if (rel.predicate.includes(\"many-to-many\") || rel.predicate === \"has-many-to-many\") {\n          cardinality = \"many-to-many\";\n        }\n\n        cardinalities.push({\n          sourceEntity: element.path || element.id || \"\",\n          targetEntity: rel.target,\n          cardinality,\n          isOptional: rel.properties?.optional === true || false,\n        });\n      }\n    }\n\n    return cardinalities;\n  }\n\n  /**\n   * Find data quality issues\n   */\n  async identifyIssues(): Promise<DataQualityIssue[]> {\n    const issues: DataQualityIssue[] = [];\n    const entities = await this.analyzeEntities();\n    const constraints = await this.checkConstraints();\n\n    // Add constraint issues\n    for (const constraint of constraints) {\n      if (!constraint.isValid) {\n        issues.push({\n          type: constraint.constraintType === \"not-null\" ? \"incomplete\" : \"missing-constraint\",\n          entityId: constraint.entityId,\n          description: constraint.description,\n          severity: \"medium\",\n        });\n      }\n    }\n\n    // Find orphaned entities\n    for (const entity of entities) {\n      if (!entity.isReferenced && entity.relatedEntities.length === 0) {\n        issues.push({\n          type: \"orphaned\",\n          entityId: entity.id,\n          description: `Entity \"${entity.name}\" is not referenced and has no relationships`,\n          severity: \"low\",\n        });\n      }\n    }\n\n    return issues;\n  }\n\n  /**\n   * Calculate coverage metrics\n   */\n  async calculateCoverage(): Promise<DataModelCoverageMetrics> {\n    const entities = await this.analyzeEntities();\n\n    let documentsCount = 0;\n    let constraintCount = 0;\n    let referencedCount = 0;\n    let orphanedCount = 0;\n\n    for (const entity of entities) {\n      if (entity.attributes && entity.attributes.length > 0) {\n        documentsCount++;\n      }\n\n      if (entity.isReferenced) {\n        referencedCount++;\n      }\n\n      if (!entity.isReferenced && entity.relatedEntities.length === 0) {\n        orphanedCount++;\n      }\n\n      // Simple heuristic for constraints: if entity has attributes\n      if (entity.attributes && entity.attributes.length > 0) {\n        constraintCount++;\n      }\n    }\n\n    const totalEntities = entities.length;\n\n    return {\n      totalEntities,\n      entitiesWithAttributes: documentsCount,\n      constraintsEntities: constraintCount,\n      referencedEntities: referencedCount,\n      orphanedEntities: orphanedCount,\n      attributeCoverage:\n        totalEntities > 0 ? Math.round((documentsCount / totalEntities) * 100) : 0,\n      constraintCoverage: totalEntities > 0 ? Math.round((constraintCount / totalEntities) * 100) : 0,\n      referenceCoverage: totalEntities > 0 ? Math.round((referencedCount / totalEntities) * 100) : 0,\n    };\n  }\n\n  /**\n   * Calculate complexity metrics\n   */\n  async calculateComplexity(): Promise<DataModelComplexityMetrics> {\n    const entities = await this.analyzeEntities();\n\n    if (entities.length === 0) {\n      return {\n        avgAttributesPerEntity: 0,\n        maxAttributesPerEntity: 0,\n        minAttributesPerEntity: 0,\n        avgRelationshipsPerEntity: 0,\n        maxRelationshipsPerEntity: 0,\n        entityDensity: 0,\n      };\n    }\n\n    let totalAttributes = 0;\n    let maxAttributes = 0;\n    let minAttributes = Infinity;\n    let totalRelationships = 0;\n    let maxRelationships = 0;\n\n    for (const entity of entities) {\n      const attrCount = entity.attributes.length;\n      const relCount = entity.relatedEntities.length;\n\n      totalAttributes += attrCount;\n      totalRelationships += relCount;\n\n      maxAttributes = Math.max(maxAttributes, attrCount);\n      minAttributes = Math.min(minAttributes, attrCount);\n      maxRelationships = Math.max(maxRelationships, relCount);\n    }\n\n    const avgAttributes = totalAttributes / entities.length;\n    const avgRelationships = totalRelationships / entities.length;\n    const density =\n      entities.length > 0\n        ? totalRelationships / (entities.length * entities.length)\n        : 0;\n\n    return {\n      avgAttributesPerEntity: Math.round(avgAttributes * 10) / 10,\n      maxAttributesPerEntity: maxAttributes,\n      minAttributesPerEntity: minAttributes === Infinity ? 0 : minAttributes,\n      avgRelationshipsPerEntity: Math.round(avgRelationships * 10) / 10,\n      maxRelationshipsPerEntity: maxRelationships,\n      entityDensity: Math.round(density * 10000) / 10000,\n    };\n  }\n\n  /**\n   * Get entity dependency graph\n   */\n  async getEntityDependencyGraph(): Promise<Map<string, Set<string>>> {\n    const entities = await this.analyzeEntities();\n    const graph = new Map<string, Set<string>>();\n\n    for (const entity of entities) {\n      if (!graph.has(entity.id)) {\n        graph.set(entity.id, new Set());\n      }\n\n      for (const relatedId of entity.relatedEntities) {\n        const deps = graph.get(entity.id)!;\n        deps.add(relatedId);\n      }\n    }\n\n    return graph;\n  }\n\n  /**\n   * Find entity clusters based on relationships\n   */\n  async findClusters(): Promise<Set<string>[]> {\n    const graph = await this.getEntityDependencyGraph();\n    const visited = new Set<string>();\n    const clusters: Set<string>[] = [];\n\n    for (const nodeId of graph.keys()) {\n      if (!visited.has(nodeId)) {\n        const cluster = new Set<string>();\n        this.dfsCluster(nodeId, graph, visited, cluster);\n        clusters.push(cluster);\n      }\n    }\n\n    return clusters;\n  }\n\n  /**\n   * DFS to find connected components (clusters)\n   */\n  private dfsCluster(\n    nodeId: string,\n    graph: Map<string, Set<string>>,\n    visited: Set<string>,\n    cluster: Set<string>\n  ): void {\n    if (visited.has(nodeId)) {\n      return;\n    }\n\n    visited.add(nodeId);\n    cluster.add(nodeId);\n\n    const neighbors = graph.get(nodeId);\n    if (neighbors) {\n      for (const neighbor of neighbors) {\n        this.dfsCluster(neighbor, graph, visited, cluster);\n      }\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/analysis/index.js

@@ -0,0 +1,3 @@
+export * from "./relationship-classifier.js";
+export * from "./data-model-analyzer.js";
+//# sourceMappingURL=index.js.map

package/dist/analysis/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/analysis/index.ts"],
+  "sourcesContent": ["/**\n * Analysis module - Semantic relationship and data model analysis\n */\n\nexport * from \"./relationship-classifier.js\";\nexport * from \"./data-model-analyzer.js\";\n"],
+  "mappings": "AAIA,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/analysis/relationship-classifier.js

@@ -0,0 +1,181 @@
+import { getLayerOrder, isValidLayerName } from "../core/layers.js";
+var RelationshipStrength;
+(function(RelationshipStrength2) {
+  RelationshipStrength2.Weak = "weak", RelationshipStrength2.Medium = "medium", RelationshipStrength2.Strong = "strong";
+})(RelationshipStrength || (RelationshipStrength = {}));
+class RelationshipClassifier {
+  catalog;
+  relationshipTypeMap = /* @__PURE__ */ new Map();
+  catalogLoaded = !1;
+  constructor(catalog) {
+    this.catalog = catalog;
+  }
+  /**
+   * Load and prepare the catalog
+   */
+  async load() {
+    if (this.catalogLoaded)
+      return;
+    await this.catalog.load();
+    const types = this.catalog.getAllTypes();
+    for (const type of types)
+      this.relationshipTypeMap.set(type.predicate, type);
+    this.catalogLoaded = !0;
+  }
+  /**
+   * Classify a single relationship with detailed semantic information
+   */
+  async classify(rel, relationshipId) {
+    await this.load();
+    const sourceLayer = rel.source.split(".")[0], targetLayer = rel.target.split(".")[0], isCrossLayer = sourceLayer !== targetLayer, relationshipType = this.relationshipTypeMap.get(rel.predicate);
+    return {
+      id: relationshipId || `${rel.source}\u2192${rel.predicate}\u2192${rel.target}`,
+      source: rel.source,
+      target: rel.target,
+      predicate: rel.predicate,
+      category: relationshipType?.category || "unknown",
+      archimateAlignment: relationshipType?.archimateAlignment || null,
+      directionality: relationshipType?.semantics?.directionality || "unidirectional",
+      transitivity: relationshipType?.semantics?.transitivity || !1,
+      symmetry: relationshipType?.semantics?.symmetry || !1,
+      reflexivity: relationshipType?.semantics?.reflexivity,
+      sourceLayer,
+      targetLayer,
+      isCrossLayer,
+      isSpecCompliant: relationshipType !== void 0
+    };
+  }
+  /**
+   * Classify a batch of relationships
+   */
+  async classifyBatch(relationships) {
+    const classified = [];
+    for (let i = 0; i < relationships.length; i++) {
+      const rel = relationships[i], relationshipId = `${rel.source}\u2192${rel.predicate}\u2192${rel.target}`, classifiedRel = await this.classify(rel, relationshipId);
+      classified.push(classifiedRel);
+    }
+    return classified;
+  }
+  /**
+   * Get relationship breakdown by category
+   */
+  async getCategoryBreakdown(relationships) {
+    const byCategory = {};
+    for (const rel of relationships)
+      byCategory[rel.category] || (byCategory[rel.category] = []), byCategory[rel.category].push(rel);
+    const breakdown = [];
+    for (const [category, rels] of Object.entries(byCategory)) {
+      const predicates = Array.from(new Set(rels.map((r) => r.predicate))), avgStrength = this.calculateAverageStrength(rels);
+      breakdown.push({
+        category,
+        count: rels.length,
+        percentage: rels.length / relationships.length * 100,
+        predicates,
+        avgStrength
+      });
+    }
+    return breakdown.sort((a, b) => b.count - a.count);
+  }
+  /**
+   * Analyze transitive relationships for a specific predicate
+   */
+  async analyzeTransitivity(relationships, predicate) {
+    const isTransitive = this.relationshipTypeMap.get(predicate)?.semantics.transitivity || !1, chains = [];
+    if (isTransitive) {
+      const relsByPredicate = relationships.filter((r) => r.predicate === predicate);
+      for (const rel1 of relsByPredicate)
+        for (const rel2 of relsByPredicate)
+          rel1.target === rel2.source && rel1.source !== rel2.target && chains.push({
+            elements: [rel1.source, rel1.target, rel2.target],
+            pathLength: 2
+          });
+      const uniqueChains = Array.from(new Map(chains.map((c) => [c.elements.join("\u2192"), c])).values());
+      return {
+        predicate,
+        isTransitive: !0,
+        chains: uniqueChains
+      };
+    }
+    return {
+      predicate,
+      isTransitive: !1,
+      chains: []
+    };
+  }
+  /**
+   * Validate a relationship against semantic rules
+   */
+  async validateSemantics(rel) {
+    await this.load();
+    const issues = [], warnings = [], relationshipType = this.relationshipTypeMap.get(rel.predicate);
+    return relationshipType ? (!relationshipType.semantics.reflexivity && rel.source === rel.target && issues.push(`Predicate "${rel.predicate}" does not support reflexive relationships`), relationshipType.semantics.symmetry && rel.directionality === "unidirectional" && warnings.push(`Predicate "${rel.predicate}" is symmetric but may be unidirectional`), rel.isCrossLayer && (!isValidLayerName(rel.sourceLayer) || !isValidLayerName(rel.targetLayer) ? warnings.push(`Cross-layer relationship references unknown layer(s): ${rel.sourceLayer} \u2192 ${rel.targetLayer}`) : this.getLayerOrder(rel.sourceLayer, rel.targetLayer) < 0 && warnings.push(`Cross-layer relationship violates layer hierarchy: ${rel.sourceLayer} \u2192 ${rel.targetLayer}`))) : issues.push(`Unknown predicate: ${rel.predicate}`), {
+      isValid: issues.length === 0,
+      category: rel.category,
+      predicate: rel.predicate,
+      issues,
+      warnings
+    };
+  }
+  /**
+   * Validate a batch of relationships
+   */
+  async validateBatch(relationships) {
+    const results = [];
+    for (const rel of relationships) {
+      const result = await this.validateSemantics(rel);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Find relationships that violate semantic rules
+   */
+  async findSemanticViolations(relationships) {
+    return (await this.validateBatch(relationships)).filter((v) => !v.isValid || v.issues.length > 0);
+  }
+  /**
+   * Analyze relationship patterns
+   */
+  async analyzePatterns(relationships) {
+    const byPredicate = {};
+    for (const rel of relationships)
+      byPredicate[rel.predicate] || (byPredicate[rel.predicate] = []), byPredicate[rel.predicate].push(rel);
+    const patterns = [];
+    for (const [predicate, rels] of Object.entries(byPredicate)) {
+      const relationshipType = this.relationshipTypeMap.get(predicate), examples = rels.slice(0, 3).map((r) => `${r.source} \u2192 ${r.target}`), avgStrength = this.calculateAverageStrength(rels);
+      patterns.push({
+        predicate,
+        category: relationshipType?.category || "unknown",
+        count: rels.length,
+        percentage: rels.length / relationships.length * 100,
+        averageStrength: avgStrength,
+        examples
+      });
+    }
+    return patterns.sort((a, b) => b.count - a.count);
+  }
+  /**
+   * Calculate average relationship strength
+   */
+  calculateAverageStrength(relationships) {
+    if (relationships.length === 0)
+      return RelationshipStrength.Medium;
+    let strongCount = 0, weakCount = 0;
+    for (const rel of relationships)
+      rel.transitivity && rel.symmetry ? strongCount++ : rel.directionality === "unidirectional" && rel.reflexivity === !1 && weakCount++;
+    const strongPercentage = strongCount / relationships.length * 100, weakPercentage = weakCount / relationships.length * 100;
+    return strongPercentage > 50 ? RelationshipStrength.Strong : weakPercentage > 50 ? RelationshipStrength.Weak : RelationshipStrength.Medium;
+  }
+  /**
+   * Get layer ordering for compliance checking
+   */
+  getLayerOrder(layer1, layer2) {
+    const order1 = getLayerOrder(layer1), order2 = getLayerOrder(layer2);
+    return order1 - order2;
+  }
+}
+export {
+  RelationshipClassifier,
+  RelationshipStrength
+};
+//# sourceMappingURL=relationship-classifier.js.map

package/dist/analysis/relationship-classifier.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/analysis/relationship-classifier.ts"],
+  "sourcesContent": ["/**\n * Relationship Classifier - Semantic classification of relationships\n *\n * Classifies relationships by semantic category, strength, and directionality.\n * Analyzes relationship patterns, validates against schemas, and detects issues.\n */\n\nimport { RelationshipCatalog, RelationshipType } from \"../core/relationship-catalog.js\";\nimport { ClassifiedRelationship } from \"../core/report-data-model.js\";\nimport { getLayerOrder, isValidLayerName } from \"../core/layers.js\";\nimport type { Relationship } from \"../types/index.js\";\n\n/**\n * Relationship strength assessment\n */\nexport enum RelationshipStrength {\n  Weak = \"weak\",\n  Medium = \"medium\",\n  Strong = \"strong\",\n}\n\n/**\n * Relationship pattern analysis result\n */\nexport interface RelationshipPattern {\n  predicate: string;\n  category: string;\n  count: number;\n  percentage: number;\n  averageStrength: RelationshipStrength;\n  examples: string[];\n}\n\n/**\n * Transitive analysis result\n */\nexport interface TransitiveAnalysis {\n  predicate: string;\n  isTransitive: boolean;\n  chains: TransitiveChain[];\n}\n\n/**\n * Transitive chain (A -> B -> C where A is implied to relate to C)\n */\nexport interface TransitiveChain {\n  elements: string[];\n  pathLength: number;\n}\n\n/**\n * Classification statistics grouped by category\n */\nexport interface CategoryStatistics {\n  category: string;\n  count: number;\n  percentage: number;\n  predicates: string[];\n  avgStrength: RelationshipStrength;\n}\n\n/**\n * Validates and analyzes semantic compliance\n */\nexport interface SemanticValidationResult {\n  isValid: boolean;\n  category: string;\n  predicate: string;\n  issues: string[];\n  warnings: string[];\n}\n\n/**\n * Relationship Classifier\n */\nexport class RelationshipClassifier {\n  private catalog: RelationshipCatalog;\n  private relationshipTypeMap: Map<string, RelationshipType> = new Map();\n  private catalogLoaded = false;\n\n  constructor(catalog: RelationshipCatalog) {\n    this.catalog = catalog;\n  }\n\n  /**\n   * Load and prepare the catalog\n   */\n  async load(): Promise<void> {\n    if (this.catalogLoaded) return;\n\n    await this.catalog.load();\n    const types = this.catalog.getAllTypes();\n\n    for (const type of types) {\n      this.relationshipTypeMap.set(type.predicate, type);\n    }\n\n    this.catalogLoaded = true;\n  }\n\n  /**\n   * Classify a single relationship with detailed semantic information\n   */\n  async classify(\n    rel: Relationship,\n    relationshipId?: string\n  ): Promise<ClassifiedRelationship> {\n    await this.load();\n\n    const sourceLayer = rel.source.split(\".\")[0];\n    const targetLayer = rel.target.split(\".\")[0];\n    const isCrossLayer = sourceLayer !== targetLayer;\n\n    const relationshipType = this.relationshipTypeMap.get(rel.predicate);\n\n    return {\n      id: relationshipId || `${rel.source}\u2192${rel.predicate}\u2192${rel.target}`,\n      source: rel.source,\n      target: rel.target,\n      predicate: rel.predicate,\n      category: relationshipType?.category || \"unknown\",\n      archimateAlignment: relationshipType?.archimateAlignment || null,\n      directionality: relationshipType?.semantics?.directionality || \"unidirectional\",\n      transitivity: relationshipType?.semantics?.transitivity || false,\n      symmetry: relationshipType?.semantics?.symmetry || false,\n      reflexivity: relationshipType?.semantics?.reflexivity,\n      sourceLayer,\n      targetLayer,\n      isCrossLayer,\n      isSpecCompliant: relationshipType !== undefined,\n    };\n  }\n\n  /**\n   * Classify a batch of relationships\n   */\n  async classifyBatch(\n    relationships: Relationship[]\n  ): Promise<ClassifiedRelationship[]> {\n    const classified: ClassifiedRelationship[] = [];\n\n    for (let i = 0; i < relationships.length; i++) {\n      const rel = relationships[i];\n      const relationshipId = `${rel.source}\u2192${rel.predicate}\u2192${rel.target}`;\n      const classifiedRel = await this.classify(rel, relationshipId);\n      classified.push(classifiedRel);\n    }\n\n    return classified;\n  }\n\n  /**\n   * Get relationship breakdown by category\n   */\n  async getCategoryBreakdown(\n    relationships: ClassifiedRelationship[]\n  ): Promise<CategoryStatistics[]> {\n    const byCategory: Record<string, ClassifiedRelationship[]> = {};\n\n    for (const rel of relationships) {\n      if (!byCategory[rel.category]) {\n        byCategory[rel.category] = [];\n      }\n      byCategory[rel.category].push(rel);\n    }\n\n    const breakdown: CategoryStatistics[] = [];\n\n    for (const [category, rels] of Object.entries(byCategory)) {\n      const predicates = Array.from(new Set(rels.map((r) => r.predicate)));\n      const avgStrength = this.calculateAverageStrength(rels);\n\n      breakdown.push({\n        category,\n        count: rels.length,\n        percentage: (rels.length / relationships.length) * 100,\n        predicates,\n        avgStrength,\n      });\n    }\n\n    return breakdown.sort((a, b) => b.count - a.count);\n  }\n\n  /**\n   * Analyze transitive relationships for a specific predicate\n   */\n  async analyzeTransitivity(\n    relationships: ClassifiedRelationship[],\n    predicate: string\n  ): Promise<TransitiveAnalysis> {\n    const type = this.relationshipTypeMap.get(predicate);\n    const isTransitive = type?.semantics.transitivity || false;\n\n    const chains: TransitiveChain[] = [];\n\n    if (isTransitive) {\n      // Build a map of relationships for this predicate\n      const relsByPredicate = relationships.filter((r) => r.predicate === predicate);\n\n      // Find chains A -> B -> C\n      for (const rel1 of relsByPredicate) {\n        for (const rel2 of relsByPredicate) {\n          if (rel1.target === rel2.source && rel1.source !== rel2.target) {\n            chains.push({\n              elements: [rel1.source, rel1.target, rel2.target],\n              pathLength: 2,\n            });\n          }\n        }\n      }\n\n      // Remove duplicate chains\n      const uniqueChains = Array.from(\n        new Map(chains.map((c) => [c.elements.join(\"\u2192\"), c])).values()\n      );\n\n      return {\n        predicate,\n        isTransitive: true,\n        chains: uniqueChains,\n      };\n    }\n\n    return {\n      predicate,\n      isTransitive: false,\n      chains: [],\n    };\n  }\n\n  /**\n   * Validate a relationship against semantic rules\n   */\n  async validateSemantics(\n    rel: ClassifiedRelationship\n  ): Promise<SemanticValidationResult> {\n    await this.load();\n\n    const issues: string[] = [];\n    const warnings: string[] = [];\n\n    const relationshipType = this.relationshipTypeMap.get(rel.predicate);\n\n    if (!relationshipType) {\n      issues.push(`Unknown predicate: ${rel.predicate}`);\n    } else {\n      // Check reflexivity\n      if (!relationshipType.semantics.reflexivity && rel.source === rel.target) {\n        issues.push(`Predicate \"${rel.predicate}\" does not support reflexive relationships`);\n      }\n\n      // Check symmetry\n      if (relationshipType.semantics.symmetry && rel.directionality === \"unidirectional\") {\n        warnings.push(`Predicate \"${rel.predicate}\" is symmetric but may be unidirectional`);\n      }\n\n      // Check layer direction for cross-layer relationships\n      if (rel.isCrossLayer) {\n        // First check if both layers are valid\n        if (!isValidLayerName(rel.sourceLayer) || !isValidLayerName(rel.targetLayer)) {\n          warnings.push(\n            `Cross-layer relationship references unknown layer(s): ${rel.sourceLayer} \u2192 ${rel.targetLayer}`\n          );\n        } else {\n          // Only check hierarchy if both layers are known\n          const layerOrder = this.getLayerOrder(rel.sourceLayer, rel.targetLayer);\n          if (layerOrder < 0) {\n            warnings.push(\n              `Cross-layer relationship violates layer hierarchy: ${rel.sourceLayer} \u2192 ${rel.targetLayer}`\n            );\n          }\n        }\n      }\n    }\n\n    return {\n      isValid: issues.length === 0,\n      category: rel.category,\n      predicate: rel.predicate,\n      issues,\n      warnings,\n    };\n  }\n\n  /**\n   * Validate a batch of relationships\n   */\n  async validateBatch(\n    relationships: ClassifiedRelationship[]\n  ): Promise<SemanticValidationResult[]> {\n    const results: SemanticValidationResult[] = [];\n\n    for (const rel of relationships) {\n      const result = await this.validateSemantics(rel);\n      results.push(result);\n    }\n\n    return results;\n  }\n\n  /**\n   * Find relationships that violate semantic rules\n   */\n  async findSemanticViolations(\n    relationships: ClassifiedRelationship[]\n  ): Promise<SemanticValidationResult[]> {\n    const validations = await this.validateBatch(relationships);\n    return validations.filter((v) => !v.isValid || v.issues.length > 0);\n  }\n\n  /**\n   * Analyze relationship patterns\n   */\n  async analyzePatterns(\n    relationships: ClassifiedRelationship[]\n  ): Promise<RelationshipPattern[]> {\n    const byPredicate: Record<string, ClassifiedRelationship[]> = {};\n\n    for (const rel of relationships) {\n      if (!byPredicate[rel.predicate]) {\n        byPredicate[rel.predicate] = [];\n      }\n      byPredicate[rel.predicate].push(rel);\n    }\n\n    const patterns: RelationshipPattern[] = [];\n\n    for (const [predicate, rels] of Object.entries(byPredicate)) {\n      const relationshipType = this.relationshipTypeMap.get(predicate);\n      const examples = rels.slice(0, 3).map((r) => `${r.source} \u2192 ${r.target}`);\n      const avgStrength = this.calculateAverageStrength(rels);\n\n      patterns.push({\n        predicate,\n        category: relationshipType?.category || \"unknown\",\n        count: rels.length,\n        percentage: (rels.length / relationships.length) * 100,\n        averageStrength: avgStrength,\n        examples,\n      });\n    }\n\n    return patterns.sort((a, b) => b.count - a.count);\n  }\n\n  /**\n   * Calculate average relationship strength\n   */\n  private calculateAverageStrength(\n    relationships: ClassifiedRelationship[]\n  ): RelationshipStrength {\n    if (relationships.length === 0) return RelationshipStrength.Medium;\n\n    let strongCount = 0;\n    let weakCount = 0;\n\n    for (const rel of relationships) {\n      // Strong: transitive, symmetric relationships\n      if (rel.transitivity && rel.symmetry) {\n        strongCount++;\n      }\n      // Weak: unidirectional, non-reflexive\n      else if (rel.directionality === \"unidirectional\" && rel.reflexivity === false) {\n        weakCount++;\n      }\n    }\n\n    const strongPercentage = (strongCount / relationships.length) * 100;\n    const weakPercentage = (weakCount / relationships.length) * 100;\n\n    if (strongPercentage > 50) {\n      return RelationshipStrength.Strong;\n    } else if (weakPercentage > 50) {\n      return RelationshipStrength.Weak;\n    }\n\n    return RelationshipStrength.Medium;\n  }\n\n  /**\n   * Get layer ordering for compliance checking\n   */\n  private getLayerOrder(layer1: string, layer2: string): number {\n    const order1 = getLayerOrder(layer1);\n    const order2 = getLayerOrder(layer2);\n    return order1 - order2;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["RelationshipStrength"]
+}

package/dist/analyzers/base-analyzer.js

@@ -0,0 +1 @@
+//# sourceMappingURL=base-analyzer.js.map

package/dist/analyzers/base-analyzer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/analyzers/call-graph-utils.js

@@ -0,0 +1,39 @@
+import { relative } from "node:path";
+function isEdgeType(value) {
+  return value === "CALLS" || value === "HTTP_CALLS" || value === "HANDLES";
+}
+function clampDepth(depth) {
+  return Math.max(Math.min(depth ?? 3, 10), 0);
+}
+function shapeCallGraphNode(responseNode, projectRoot) {
+  let sourceFile = responseNode.file_path || responseNode.source_file || "";
+  if (sourceFile && projectRoot)
+    try {
+      if (typeof sourceFile != "string" || typeof projectRoot != "string")
+        throw new TypeError(`Invalid path types: sourceFile=${typeof sourceFile}, projectRoot=${typeof projectRoot}`);
+      sourceFile = relative(projectRoot, sourceFile);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Warning: Failed to compute relative path for "${sourceFile}": ${errorMessage}`);
+    }
+  return {
+    qualified_name: responseNode.qualified_name || responseNode.id,
+    source_file: sourceFile,
+    source_symbol: responseNode.source_symbol || responseNode.id || "",
+    depth: typeof responseNode.depth == "number" ? responseNode.depth : 0,
+    edge_type: "CALLS"
+  };
+}
+function determineEdgeType(nodeDepth, edges, targetNodeQualifiedName, validEdgeTypes = ["CALLS", "HTTP_CALLS", "HANDLES"]) {
+  const defaultEdgeType = validEdgeTypes[0] || "CALLS";
+  if (nodeDepth === 0)
+    return isEdgeType(defaultEdgeType) ? defaultEdgeType : "CALLS";
+  const incomingEdge = edges.find((edge) => edge.to_node === targetNodeQualifiedName);
+  return incomingEdge && incomingEdge.type && validEdgeTypes.includes(incomingEdge.type) && isEdgeType(incomingEdge.type) ? incomingEdge.type : isEdgeType(defaultEdgeType) ? defaultEdgeType : "CALLS";
+}
+export {
+  clampDepth,
+  determineEdgeType,
+  shapeCallGraphNode
+};
+//# sourceMappingURL=call-graph-utils.js.map

package/dist/analyzers/call-graph-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/analyzers/call-graph-utils.ts"],
+  "sourcesContent": ["/**\n * Utilities for call graph analysis\n */\n\nimport { relative } from \"node:path\";\nimport type { CallGraphNode } from \"./types.js\";\n\n/**\n * Valid edge types for call graph edges\n */\ntype EdgeType = \"CALLS\" | \"HTTP_CALLS\" | \"HANDLES\";\n\n/**\n * Type guard to ensure a value is a valid edge type\n */\nfunction isEdgeType(value: unknown): value is EdgeType {\n  return value === \"CALLS\" || value === \"HTTP_CALLS\" || value === \"HANDLES\";\n}\n\n/**\n * Clamp depth to valid range (default 3, min 0, max 10)\n */\nexport function clampDepth(depth: number | undefined): number {\n  return Math.max(Math.min(depth ?? 3, 10), 0);\n}\n\n/**\n * Shape raw response node to CallGraphNode\n */\nexport function shapeCallGraphNode(\n  responseNode: any,\n  projectRoot?: string\n): CallGraphNode {\n  // Extract source file and compute relative path if projectRoot provided\n  let sourceFile = responseNode.file_path || responseNode.source_file || \"\";\n  if (sourceFile && projectRoot) {\n    try {\n      // Validate inputs are strings before calling path.relative()\n      if (typeof sourceFile !== \"string\" || typeof projectRoot !== \"string\") {\n        throw new TypeError(\n          `Invalid path types: sourceFile=${typeof sourceFile}, projectRoot=${typeof projectRoot}`\n        );\n      }\n      sourceFile = relative(projectRoot, sourceFile);\n    } catch (error) {\n      // Log the error but keep the original path\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      console.warn(\n        `Warning: Failed to compute relative path for \"${sourceFile}\": ${errorMessage}`\n      );\n    }\n  }\n\n  return {\n    qualified_name: responseNode.qualified_name || responseNode.id,\n    source_file: sourceFile,\n    source_symbol: responseNode.source_symbol || responseNode.id || \"\",\n    depth: typeof responseNode.depth === \"number\" ? responseNode.depth : 0,\n    edge_type: \"CALLS\",\n  };\n}\n\n/**\n * Determine edge type based on node depth and edges list\n */\nexport function determineEdgeType(\n  nodeDepth: number,\n  edges: Array<{ from_node: string; to_node: string; type?: string }>,\n  targetNodeQualifiedName: string,\n  validEdgeTypes: string[] = [\"CALLS\", \"HTTP_CALLS\", \"HANDLES\"]\n): EdgeType {\n  const defaultEdgeType = validEdgeTypes[0] || \"CALLS\";\n\n  // For root nodes (depth 0), always use default\n  if (nodeDepth === 0) {\n    // Validate that default is a known edge type\n    if (!isEdgeType(defaultEdgeType)) {\n      return \"CALLS\"; // Fallback to safe default\n    }\n    return defaultEdgeType;\n  }\n\n  // For non-root nodes, find incoming edge\n  const incomingEdge = edges.find(\n    (edge) => edge.to_node === targetNodeQualifiedName\n  );\n  if (incomingEdge && incomingEdge.type && validEdgeTypes.includes(incomingEdge.type)) {\n    // Validate that the edge type is known\n    if (isEdgeType(incomingEdge.type)) {\n      return incomingEdge.type;\n    }\n  }\n\n  // Return validated default\n  if (!isEdgeType(defaultEdgeType)) {\n    return \"CALLS\"; // Fallback to safe default\n  }\n  return defaultEdgeType;\n}\n"],
+  "mappings": "AAIA,SAAS,gBAAgB;AAWzB,SAAS,WAAW,OAAc;AAChC,SAAO,UAAU,WAAW,UAAU,gBAAgB,UAAU;AAClE;AAKM,SAAU,WAAW,OAAyB;AAClD,SAAO,KAAK,IAAI,KAAK,IAAI,SAAS,GAAG,EAAE,GAAG,CAAC;AAC7C;AAKM,SAAU,mBACd,cACA,aAAoB;AAGpB,MAAI,aAAa,aAAa,aAAa,aAAa,eAAe;AACvE,MAAI,cAAc;AAChB,QAAI;AAEF,UAAI,OAAO,cAAe,YAAY,OAAO,eAAgB;AAC3D,cAAM,IAAI,UACR,kCAAkC,OAAO,UAAU,iBAAiB,OAAO,WAAW,EAAE;AAG5F,mBAAa,SAAS,aAAa,UAAU;IAC/C,SAAS,OAAO;AAEd,YAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC1E,cAAQ,KACN,iDAAiD,UAAU,MAAM,YAAY,EAAE;IAEnF;AAGF,SAAO;IACL,gBAAgB,aAAa,kBAAkB,aAAa;IAC5D,aAAa;IACb,eAAe,aAAa,iBAAiB,aAAa,MAAM;IAChE,OAAO,OAAO,aAAa,SAAU,WAAW,aAAa,QAAQ;IACrE,WAAW;;AAEf;AAKM,SAAU,kBACd,WACA,OACA,yBACA,iBAA2B,CAAC,SAAS,cAAc,SAAS,GAAC;AAE7D,QAAM,kBAAkB,eAAe,CAAC,KAAK;AAG7C,MAAI,cAAc;AAEhB,WAAK,WAAW,eAAe,IAGxB,kBAFE;AAMX,QAAM,eAAe,MAAM,KACzB,CAAC,SAAS,KAAK,YAAY,uBAAuB;AAEpD,SAAI,gBAAgB,aAAa,QAAQ,eAAe,SAAS,aAAa,IAAI,KAE5E,WAAW,aAAa,IAAI,IACvB,aAAa,OAKnB,WAAW,eAAe,IAGxB,kBAFE;AAGX;",
+  "names": []
+}