@domainlang/language 0.11.0 → 0.13.0

package/src/sdk/ast-augmentation.ts

@@ -46,15 +46,19 @@
  * - `fqn` - Computed fully qualified name
  * - `hasType(name)` - Check type matches
  *
- * **Properties added to Relationship:**
- * - `hasPattern(pattern)` - Check if pattern exists on either side
- * - `hasLeftPattern(pattern)` - Check left patterns
- * - `hasRightPattern(pattern)` - Check right patterns
+ * **Properties added to DirectionalRelationship:**
+ * - `isBidirectional` - Check if relationship is bidirectional (`<->`)
+ * - `leftContextName` - Resolved name of left context (handles `this`)
+ * - `rightContextName` - Resolved name of right context (handles `this`)
+ * - `hasPattern(patternType)` - Check if pattern exists on either side
+ * - `hasLeftPattern(patternType)` - Check left patterns
+ * - `hasRightPattern(patternType)` - Check right patterns
  * - `isUpstream(side)` - Check if side is upstream
  * - `isDownstream(side)` - Check if side is downstream
- * - `isBidirectional` - Check if relationship is bidirectional
- * - `leftContextName` - Resolved name of left context
- * - `rightContextName` - Resolved name of right context
+ *
+ * **Properties added to SymmetricRelationship:**
+ * - `leftContextName` - Resolved name of left context (handles `this`)
+ * - `rightContextName` - Resolved name of right context (handles `this`)
  *
  * @module sdk/ast-augmentation
  */
@@ -109,9 +113,9 @@ declare module '../generated/ast.js' {
     }
 
     /**
-     * Augmented Relationship with SDK helper methods.
+     * Augmented DirectionalRelationship with SDK helper methods.
      */
-    interface Relationship {
+    interface DirectionalRelationship {
         /** Resolved name of left context (handles 'this') */
         readonly leftContextName: string;
         /** Resolved name of right context (handles 'this') */
@@ -120,36 +124,41 @@ declare module '../generated/ast.js' {
         readonly isBidirectional: boolean;
         
         /**
-         * Checks if the relationship has a specific integration pattern on either side.
-         * Accepts both abbreviations (SK, ACL) and full names (SharedKernel, AntiCorruptionLayer).
-         * @param pattern - Pattern abbreviation or full name
+         * Checks if the relationship has a specific side pattern on either side.
+         * Accepts pattern $type names like 'OpenHostService', 'Conformist', etc.
          */
-        hasPattern(pattern: import('./patterns.js').IntegrationPattern | string): boolean;
+        hasPattern(patternType: string): boolean;
         
         /**
-         * Checks if the left side has a specific integration pattern.
-         * @param pattern - Pattern abbreviation or full name
+         * Checks if the left side has a specific side pattern.
          */
-        hasLeftPattern(pattern: import('./patterns.js').IntegrationPattern | string): boolean;
+        hasLeftPattern(patternType: string): boolean;
         
         /**
-         * Checks if the right side has a specific integration pattern.
-         * @param pattern - Pattern abbreviation or full name
+         * Checks if the right side has a specific side pattern.
          */
-        hasRightPattern(pattern: import('./patterns.js').IntegrationPattern | string): boolean;
+        hasRightPattern(patternType: string): boolean;
         
         /**
          * Checks if the specified side is upstream (provider) in this relationship.
-         * @param side - 'left' or 'right'
          */
         isUpstream(side: 'left' | 'right'): boolean;
         
         /**
          * Checks if the specified side is downstream (consumer) in this relationship.
-         * @param side - 'left' or 'right'
          */
         isDownstream(side: 'left' | 'right'): boolean;
     }
+
+    /**
+     * Augmented SymmetricRelationship with SDK helper methods.
+     */
+    interface SymmetricRelationship {
+        /** Resolved name of left context (handles 'this') */
+        readonly leftContextName: string;
+        /** Resolved name of right context (handles 'this') */
+        readonly rightContextName: string;
+    }
 }
 
 // Export nothing - this file is purely for type augmentation

package/src/sdk/index.ts

@@ -116,14 +116,19 @@ export { fromModel, fromDocument, fromServices, augmentModel } from './query.js'
 export {
     Pattern,
     PatternFullName,
+    PatternAbbreviation,
     PatternAliases,
     matchesPattern,
     isUpstreamPattern,
     isDownstreamPattern,
     isMutualPattern,
+    isUpstreamSidePattern,
+    isDownstreamSidePattern,
+    isBBoMSidePattern,
+    getPatternAbbreviation,
     UpstreamPatterns,
     DownstreamPatterns,
-    MutualPatterns,
+    SymmetricPatterns,
 } from './patterns.js';
 
 export type { IntegrationPattern } from './patterns.js';
@@ -140,6 +145,11 @@ export type {
     LoadOptions,
     BcQueryBuilder,
     RelationshipView,
+    RelationshipSide,
+    DirectionalRelationshipView,
+    DirectionalKind,
+    SymmetricRelationshipView,
+    SymmetricKind,
 } from './types.js';
 
 // Serializers for tool responses (browser-safe)

package/src/sdk/loader-node.ts

@@ -62,7 +62,7 @@ export async function loadModel(
     options?: LoadOptions
 ): Promise<QueryContext> {
     // Resolve absolute path
-    const path = await import('path');
+    const path = await import('node:path');
     const absolutePath = path.isAbsolute(entryFile) 
         ? entryFile 
         : path.resolve(options?.workspaceDir ?? process.cwd(), entryFile);
@@ -82,7 +82,7 @@ export async function loadModel(
     }
     
     // Read file content and create document
-    const fs = await import('fs/promises');
+    const fs = await import('node:fs/promises');
     const fileContent = await fs.readFile(absolutePath, 'utf-8');
     const uri = URI.file(absolutePath);
     

package/src/sdk/patterns.ts

@@ -1,147 +1,185 @@
-/**
- * Integration Patterns - Type-safe constants for DDD integration patterns.
- * 
- * Use these constants instead of magic strings when checking relationship patterns.
- * 
- * @example
- * ```typescript
- * import { Pattern } from '../sdk/patterns.js';
- * 
- * // Instead of: hasPattern('SK') or hasPattern('SharedKernel')
- * // Use:
- * if (relationship.hasPattern(Pattern.SharedKernel)) {
- *     // ...
- * }
- * ```
- */
+import type { SidePattern, SymmetricPattern } from '../generated/ast.js';
+import {
+    isOpenHostService,
+    isPublishedLanguage,
+    isConformist,
+    isAntiCorruptionLayer,
+    isSupplier,
+    isCustomer,
+    isBigBallOfMud,
+    isSharedKernel,
+    isPartnership,
+    isSeparateWays,
+} from '../generated/ast.js';
 
 /**
- * Integration pattern abbreviations as used in the grammar.
- * These are the canonical abbreviations recognized by DomainLang.
+ * Pattern constants for programmatic use.
+ * Values match the AST $type names.
  */
 export const Pattern = {
-    // Upstream patterns (provider side)
-    /** Open Host Service - exposes a clean API for consumers */
-    OHS: 'OHS',
-    /** Published Language - shared data format/protocol */
-    PL: 'PL',
-    
-    // Downstream patterns (consumer side)
-    /** Conformist - accepts upstream model without translation */
-    CF: 'CF',
-    /** Anti-Corruption Layer - translates upstream model */
-    ACL: 'ACL',
-    
-    // Mutual patterns (both sides)
-    /** Shared Kernel - shared code/model ownership */
-    SK: 'SK',
-    /** Partnership - coordinated development */
-    P: 'P',
-    
-    // Relationship types
-    /** Customer/Supplier - negotiated contract */
-    CustomerSupplier: 'Customer/Supplier',
-    /** Separate Ways - no integration */
-    SeparateWays: 'Separate Ways',
-    /** Big Ball of Mud - legacy or unstructured */
-    BigBallOfMud: 'Big Ball of Mud',
+    // Side patterns (directional)
+    OHS: 'OpenHostService',
+    PL: 'PublishedLanguage',
+    CF: 'Conformist',
+    ACL: 'AntiCorruptionLayer',
+    S: 'Supplier',
+    C: 'Customer',
+    BBoM: 'BigBallOfMud',
+    // Symmetric patterns
+    SK: 'SharedKernel',
+    P: 'Partnership',
+    SW: 'SeparateWays',
 } as const;
 
 /**
- * Full names for integration patterns.
- * Used when patterns are spelled out in documentation blocks.
+ * Mapping from short abbreviation to full $type name.
  */
-export const PatternFullName = {
+export const PatternFullName: Record<string, string> = {
     OHS: 'OpenHostService',
     PL: 'PublishedLanguage',
     CF: 'Conformist',
     ACL: 'AntiCorruptionLayer',
+    S: 'Supplier',
+    C: 'Customer',
+    BBoM: 'BigBallOfMud',
     SK: 'SharedKernel',
     P: 'Partnership',
-} as const;
+    SW: 'SeparateWays',
+};
+
+/**
+ * Mapping from $type name to short abbreviation.
+ */
+export const PatternAbbreviation: Record<string, string> = {
+    OpenHostService: 'OHS',
+    PublishedLanguage: 'PL',
+    Conformist: 'CF',
+    AntiCorruptionLayer: 'ACL',
+    Supplier: 'S',
+    Customer: 'C',
+    BigBallOfMud: 'BBoM',
+    SharedKernel: 'SK',
+    Partnership: 'P',
+    SeparateWays: 'SW',
+};
 
 /**
- * Mapping from abbreviations to full names and vice versa.
+ * All short+long forms that map to a given canonical $type name.
  */
 export const PatternAliases: Record<string, readonly string[]> = {
-    // Abbreviation -> [abbreviation, fullName]
     OHS: ['OHS', 'OpenHostService'],
     PL: ['PL', 'PublishedLanguage'],
     CF: ['CF', 'Conformist'],
     ACL: ['ACL', 'AntiCorruptionLayer'],
+    S: ['S', 'Supplier'],
+    C: ['C', 'Customer'],
+    BBoM: ['BBoM', 'BigBallOfMud'],
     SK: ['SK', 'SharedKernel'],
     P: ['P', 'Partnership'],
-    
-    // Full names map to same
+    SW: ['SW', 'SeparateWays'],
     OpenHostService: ['OHS', 'OpenHostService'],
     PublishedLanguage: ['PL', 'PublishedLanguage'],
     Conformist: ['CF', 'Conformist'],
     AntiCorruptionLayer: ['ACL', 'AntiCorruptionLayer'],
+    Supplier: ['S', 'Supplier'],
+    Customer: ['C', 'Customer'],
+    BigBallOfMud: ['BBoM', 'BigBallOfMud'],
     SharedKernel: ['SK', 'SharedKernel'],
     Partnership: ['P', 'Partnership'],
+    SeparateWays: ['SW', 'SeparateWays'],
 };
 
-/**
- * Type representing any valid integration pattern (abbreviation or full name).
- */
-export type IntegrationPattern = 
-    | typeof Pattern[keyof typeof Pattern]
-    | typeof PatternFullName[keyof typeof PatternFullName];
+/** Union of all pattern type names */
+export type IntegrationPattern = typeof Pattern[keyof typeof Pattern];
 
 /**
- * Checks if a pattern string matches any of the expected aliases.
- * Handles both abbreviations and full names case-insensitively.
- * 
- * @param actual - Pattern string from the AST
- * @param expected - Pattern to match (abbreviation or full name)
- * @returns true if patterns match
+ * Checks if a pattern name matches an expected pattern.
+ * Works with both $type names and short abbreviations.
  */
 export function matchesPattern(actual: string, expected: string): boolean {
     const normalizedActual = actual.trim();
     const aliases = PatternAliases[expected];
-    
     if (aliases) {
         return aliases.some(alias => 
             alias.toLowerCase() === normalizedActual.toLowerCase()
         );
     }
-    
-    // Fallback: direct comparison
     return normalizedActual.toLowerCase() === expected.toLowerCase();
 }
 
+/** Side patterns that belong on the upstream side */
+export const UpstreamPatterns: readonly string[] = ['OpenHostService', 'PublishedLanguage', 'Supplier'];
+/** Side patterns that belong on the downstream side */
+export const DownstreamPatterns: readonly string[] = ['Conformist', 'AntiCorruptionLayer', 'Customer'];
+/** Symmetric patterns (mutual) */
+export const SymmetricPatterns: readonly string[] = ['SharedKernel', 'Partnership', 'SeparateWays'];
+
 /**
- * Patterns that are typically on the upstream (provider) side.
+ * Checks if a side pattern AST node is an upstream pattern. 
  */
-export const UpstreamPatterns: readonly string[] = ['OHS', 'OpenHostService', 'PL', 'PublishedLanguage'];
+export function isUpstreamSidePattern(pattern: SidePattern): boolean {
+    return isOpenHostService(pattern) || isPublishedLanguage(pattern) || isSupplier(pattern);
+}
 
 /**
- * Patterns that are typically on the downstream (consumer) side.
+ * Checks if a side pattern AST node is a downstream pattern.
  */
-export const DownstreamPatterns: readonly string[] = ['CF', 'Conformist', 'ACL', 'AntiCorruptionLayer'];
+export function isDownstreamSidePattern(pattern: SidePattern): boolean {
+    return isConformist(pattern) || isAntiCorruptionLayer(pattern) || isCustomer(pattern);
+}
 
 /**
- * Patterns that require mutual/bidirectional relationships.
+ * Checks if a side pattern AST node is a Big Ball of Mud.
  */
-export const MutualPatterns: readonly string[] = ['SK', 'SharedKernel', 'P', 'Partnership'];
+export function isBBoMSidePattern(pattern: SidePattern): boolean {
+    return isBigBallOfMud(pattern);
+}
 
 /**
- * Checks if a pattern is typically an upstream pattern.
+ * Checks if a pattern string name is an upstream pattern.
  */
 export function isUpstreamPattern(pattern: string): boolean {
     return UpstreamPatterns.some(p => matchesPattern(pattern, p));
 }
 
 /**
- * Checks if a pattern is typically a downstream pattern.
+ * Checks if a pattern string name is a downstream pattern.
  */
 export function isDownstreamPattern(pattern: string): boolean {
     return DownstreamPatterns.some(p => matchesPattern(pattern, p));
 }
 
 /**
- * Checks if a pattern requires bidirectional relationships.
+ * Checks if a pattern string name is a mutual/symmetric pattern.
  */
 export function isMutualPattern(pattern: string): boolean {
-    return MutualPatterns.some(p => matchesPattern(pattern, p));
+    return SymmetricPatterns.some(p => matchesPattern(pattern, p));
+}
+
+/**
+ * Gets the short abbreviation for a pattern $type name.
+ */
+export function getPatternAbbreviation(typeName: string): string {
+    return PatternAbbreviation[typeName] ?? typeName;
+}
+
+/**
+ * Checks if a symmetric pattern is a Shared Kernel.
+ */
+export function isSharedKernelPattern(pattern: SymmetricPattern): boolean {
+    return isSharedKernel(pattern);
+}
+
+/**
+ * Checks if a symmetric pattern is a Partnership.
+ */
+export function isPartnershipPattern(pattern: SymmetricPattern): boolean {
+    return isPartnership(pattern);
+}
+
+/**
+ * Checks if a symmetric pattern is Separate Ways.
+ */
+export function isSeparateWaysPattern(pattern: SymmetricPattern): boolean {
+    return isSeparateWays(pattern);
 }

package/src/sdk/query.ts

@@ -21,12 +21,16 @@ import {
     isBoundedContext,
     isClassification,
     isContextMap,
+    isDirectionalRelationship,
     isDomain,
     isDomainMap,
     isModel,
     isNamespaceDeclaration,
+    isSymmetricRelationship,
     isTeam,
     isThisRef,
+    isSupplier,
+    isCustomer,
 } from '../generated/ast.js';
 import { QualifiedNameProvider } from '../lsp/domain-lang-naming.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
@@ -39,6 +43,7 @@ import {
 import { isDownstreamPattern, isUpstreamPattern, matchesPattern } from './patterns.js';
 import type {
     BcQueryBuilder,
+    DirectionalKind,
     ModelIndexes,
     Query,
     QueryBuilder,
@@ -331,14 +336,39 @@ class QueryImpl implements Query {
             return undefined;
         }
 
+        if (isSymmetricRelationship(rel)) {
+            // Grammar invariant: either `arrow === '><'` (SeparateWays shorthand, pattern undefined)
+            // OR `pattern` is set (explicit [SK]/[P]/[SW] brackets). Never both; never neither
+            // (validation rejects a bare "A B" without pattern or arrow).
+            // The fallback to 'SeparateWays' correctly handles the `><` case.
+            return {
+                type: 'symmetric' as const,
+                kind: (rel.pattern?.$type ?? 'SeparateWays') as 'SharedKernel' | 'Partnership' | 'SeparateWays',
+                left: { context: left, patterns: [] },
+                right: { context: right, patterns: [] },
+                source,
+                astNode: rel,
+            };
+        }
+
+        const arrow = rel.arrow as '->' | '<-' | '<->';
+        const leftSide = { context: left, patterns: rel.leftPatterns };
+        const rightSide = { context: right, patterns: rel.rightPatterns };
+        const hasSupplier = rel.leftPatterns.some(isSupplier) || rel.rightPatterns.some(isSupplier);
+        const hasCustomer = rel.leftPatterns.some(isCustomer) || rel.rightPatterns.some(isCustomer);
+        const kind: DirectionalKind = arrow === '<->'
+            ? 'Bidirectional'
+            : (hasSupplier || hasCustomer) ? 'CustomerSupplier' : 'UpstreamDownstream';
+        const upstreamSide = arrow === '->' ? leftSide : arrow === '<-' ? rightSide : undefined;
+        const downstreamSide = arrow === '->' ? rightSide : arrow === '<-' ? leftSide : undefined;
         return {
-            left,
-            right,
-            arrow: rel.arrow,
-            leftPatterns: rel.leftPatterns,
-            rightPatterns: rel.rightPatterns,
-            type: rel.type,
-            inferredType: this.inferRelationshipType(rel),
+            type: 'directional' as const,
+            kind,
+            arrow,
+            left: leftSide,
+            right: rightSide,
+            upstream: upstreamSide,
+            downstream: downstreamSide,
             source,
             astNode: rel,
         };
@@ -358,41 +388,6 @@ class QueryImpl implements Query {
         return ref.link?.ref;
     }
 
-    /**
-     * Infers relationship type from integration patterns.
-     * Simple heuristic based on common DDD pattern combinations.
-     */
-    private inferRelationshipType(rel: Relationship): string | undefined {
-        const leftPatterns = rel.leftPatterns;
-        const rightPatterns = rel.rightPatterns;
-
-        // Partnership: Bidirectional with P or SK
-        if (rel.arrow === '<->' && (leftPatterns.includes('P') || leftPatterns.includes('SK'))) {
-            return 'Partnership';
-        }
-
-        // Shared Kernel: SK pattern
-        if (leftPatterns.includes('SK') || rightPatterns.includes('SK')) {
-            return 'SharedKernel';
-        }
-
-        // Customer-Supplier: OHS + CF
-        if (leftPatterns.includes('OHS') && rightPatterns.includes('CF')) {
-            return 'CustomerSupplier';
-        }
-
-        // Upstream-Downstream: directional arrow
-        if (rel.arrow === '->') {
-            return 'UpstreamDownstream';
-        }
-
-        // Separate Ways
-        if (rel.arrow === '><') {
-            return 'SeparateWays';
-        }
-
-        return undefined;
-    }
 }
 
 /**
@@ -726,38 +721,52 @@ export function augmentRelationship(rel: Relationship, containingBc?: BoundedCon
         // Helper methods for pattern matching (type-safe, no magic strings)
         hasPattern: {
             value: (pattern: string): boolean => {
-                return rel.leftPatterns.some(p => matchesPattern(p, pattern)) ||
-                       rel.rightPatterns.some(p => matchesPattern(p, pattern));
+                if (isDirectionalRelationship(rel)) {
+                    return rel.leftPatterns.some(p => matchesPattern(p.$type, pattern)) ||
+                           rel.rightPatterns.some(p => matchesPattern(p.$type, pattern));
+                }
+                if (isSymmetricRelationship(rel) && rel.pattern) {
+                    return matchesPattern(rel.pattern.$type, pattern);
+                }
+                return false;
             },
             enumerable: false,
             configurable: true,
         },
         hasLeftPattern: {
             value: (pattern: string): boolean => {
-                return rel.leftPatterns.some(p => matchesPattern(p, pattern));
+                if (isDirectionalRelationship(rel)) {
+                    return rel.leftPatterns.some(p => matchesPattern(p.$type, pattern));
+                }
+                return false;
             },
             enumerable: false,
             configurable: true,
         },
         hasRightPattern: {
             value: (pattern: string): boolean => {
-                return rel.rightPatterns.some(p => matchesPattern(p, pattern));
+                if (isDirectionalRelationship(rel)) {
+                    return rel.rightPatterns.some(p => matchesPattern(p.$type, pattern));
+                }
+                return false;
             },
             enumerable: false,
             configurable: true,
         },
         isUpstream: {
             value: (side: 'left' | 'right'): boolean => {
+                if (!isDirectionalRelationship(rel)) return false;
                 const patterns = side === 'left' ? rel.leftPatterns : rel.rightPatterns;
-                return patterns.some(p => isUpstreamPattern(p));
+                return patterns.some(p => isUpstreamPattern(p.$type));
             },
             enumerable: false,
             configurable: true,
         },
         isDownstream: {
             value: (side: 'left' | 'right'): boolean => {
+                if (!isDirectionalRelationship(rel)) return false;
                 const patterns = side === 'left' ? rel.leftPatterns : rel.rightPatterns;
-                return patterns.some(p => isDownstreamPattern(p));
+                return patterns.some(p => isDownstreamPattern(p.$type));
             },
             enumerable: false,
             configurable: true,

package/src/sdk/serializers.ts

@@ -165,18 +165,31 @@ export function serializeNode(node: AstNode, query: Query): Record<string, unkno
  * @returns Serialized relationship object
  */
 export function serializeRelationship(view: RelationshipView): Record<string, unknown> {
-    // RelationshipView.left and .right are BoundedContext (which have name property)
-    const leftName = view.left.name;
-    const rightName = view.right.name;
+    const leftName = view.left.context.name;
+    const rightName = view.right.context.name;
+    if (view.type === 'symmetric') {
+        const patternDisplay = view.kind === 'SeparateWays' ? '><' : `[${view.kind}]`;
+        return {
+            type: 'symmetric',
+            name: `${leftName} ${patternDisplay} ${rightName}`,
+            left: leftName,
+            right: rightName,
+            kind: view.kind,
+            source: view.source,
+        };
+    }
     return {
-        $type: 'Relationship',
+        type: 'directional',
+        kind: view.kind,
         name: `${leftName} ${view.arrow} ${rightName}`,
         left: leftName,
         right: rightName,
         arrow: view.arrow,
-        leftPatterns: view.leftPatterns,
-        rightPatterns: view.rightPatterns,
-        inferredType: view.inferredType,
+        leftPatterns: view.left.patterns.map(p => p.$type),
+        rightPatterns: view.right.patterns.map(p => p.$type),
+        upstreamPatterns: view.upstream?.patterns.map(p => p.$type),
+        downstreamPatterns: view.downstream?.patterns.map(p => p.$type),
+        source: view.source,
     };
 }