eventmodeler 0.3.2 → 0.3.4

package/dist/lib/diff/three-way-merge.js

@@ -0,0 +1,390 @@
+import { diffModels } from './model-differ.js';
+import { resolvePropertyConflict, isLayoutOnlyChange, categorizeFieldChanges, } from './merge-rules.js';
+function groupChangesByEntity(diff) {
+    const entityChanges = new Map();
+    const flowChanges = new Map();
+    for (const change of diff.entityChanges) {
+        entityChanges.set(change.entityId, change);
+    }
+    for (const change of diff.flowChanges) {
+        flowChanges.set(change.flowId, change);
+    }
+    return { entityChanges, flowChanges };
+}
+// Check if two entity changes are semantically identical
+function changesAreIdentical(a, b) {
+    if (a.changeType !== b.changeType)
+        return false;
+    if (a.entityType !== b.entityType)
+        return false;
+    if (a.changeType === 'added' || a.changeType === 'removed') {
+        return true;
+    }
+    const aProps = JSON.stringify(a.propertyChanges ?? []);
+    const bProps = JSON.stringify(b.propertyChanges ?? []);
+    const aFields = JSON.stringify(a.fieldChanges ?? []);
+    const bFields = JSON.stringify(b.fieldChanges ?? []);
+    return aProps === bProps && aFields === bFields;
+}
+/**
+ * Analyze two modifications and determine conflicts.
+ */
+function analyzeModificationConflicts(oursChange, theirsChange, strategy) {
+    const conflicts = [];
+    const autoResolved = [];
+    let hasHardConflict = false;
+    const entityType = oursChange.entityType;
+    const entityId = oursChange.entityId;
+    const entityName = oursChange.entityName;
+    // Analyze property conflicts
+    const oursProps = new Map((oursChange.propertyChanges ?? []).map(p => [p.property, p]));
+    const theirsProps = new Map((theirsChange.propertyChanges ?? []).map(p => [p.property, p]));
+    // Properties only in ours or theirs: auto-merge
+    for (const [prop, change] of oursProps) {
+        if (!theirsProps.has(prop)) {
+            autoResolved.push({
+                entityType,
+                entityId,
+                entityName,
+                action: `property-${prop}-from-ours`,
+            });
+        }
+    }
+    for (const [prop, change] of theirsProps) {
+        if (!oursProps.has(prop)) {
+            autoResolved.push({
+                entityType,
+                entityId,
+                entityName,
+                action: `property-${prop}-from-theirs`,
+            });
+        }
+    }
+    // Properties in both: check for conflicts
+    for (const [prop, oursProp] of oursProps) {
+        const theirsProp = theirsProps.get(prop);
+        if (!theirsProp)
+            continue;
+        const resolution = resolvePropertyConflict(prop, oursProp.newValue, theirsProp.newValue, entityType);
+        if (resolution.type === 'auto') {
+            autoResolved.push({
+                entityType,
+                entityId,
+                entityName,
+                action: resolution.action,
+            });
+        }
+        else if (resolution.type === 'hard') {
+            if (strategy) {
+                autoResolved.push({
+                    entityType,
+                    entityId,
+                    entityName,
+                    action: `${prop}-resolved-${strategy}`,
+                });
+            }
+            else {
+                hasHardConflict = true;
+                conflicts.push({
+                    entityType,
+                    entityId,
+                    entityName,
+                    reason: resolution.reason,
+                    property: prop,
+                    oursValue: oursProp.newValue,
+                    theirsValue: theirsProp.newValue,
+                });
+            }
+        }
+    }
+    // Analyze field conflicts
+    const oursFields = oursChange.fieldChanges ?? [];
+    const theirsFields = theirsChange.fieldChanges ?? [];
+    if (oursFields.length > 0 || theirsFields.length > 0) {
+        const { oursOnly, theirsOnly, conflicts: fieldConflicts } = categorizeFieldChanges(oursFields, theirsFields);
+        // Fields only in one branch: auto-merge
+        for (const field of oursOnly) {
+            autoResolved.push({
+                entityType,
+                entityId,
+                entityName,
+                action: `field-${field.fieldPath}-from-ours`,
+            });
+        }
+        for (const field of theirsOnly) {
+            autoResolved.push({
+                entityType,
+                entityId,
+                entityName,
+                action: `field-${field.fieldPath}-from-theirs`,
+            });
+        }
+        // Field conflicts
+        for (const { ours, theirs, resolution } of fieldConflicts) {
+            if (resolution.type === 'auto') {
+                autoResolved.push({
+                    entityType,
+                    entityId,
+                    entityName,
+                    action: `field-${ours.fieldPath}-${resolution.action}`,
+                });
+            }
+            else if (resolution.type === 'hard') {
+                if (strategy) {
+                    autoResolved.push({
+                        entityType,
+                        entityId,
+                        entityName,
+                        action: `field-${ours.fieldPath}-resolved-${strategy}`,
+                    });
+                }
+                else {
+                    hasHardConflict = true;
+                    conflicts.push({
+                        entityType,
+                        entityId,
+                        entityName,
+                        reason: resolution.reason,
+                        property: `field:${ours.fieldPath}`,
+                        oursValue: ours.newValue ?? ours.oldValue,
+                        theirsValue: theirs.newValue ?? theirs.oldValue,
+                    });
+                }
+            }
+        }
+    }
+    return { conflicts, autoResolved, hasHardConflict };
+}
+/**
+ * Perform a three-way merge of event models.
+ */
+export function threeWayMerge(baseModel, oursModel, theirsModel, baseEvents, oursEvents, theirsEvents, strategy) {
+    const conflicts = [];
+    const autoResolved = [];
+    // Compute diffs from base
+    const oursDiff = diffModels(baseModel, oursModel);
+    const theirsDiff = diffModels(baseModel, theirsModel);
+    const oursChanges = groupChangesByEntity(oursDiff);
+    const theirsChanges = groupChangesByEntity(theirsDiff);
+    const baseTimestamp = baseEvents.length > 0
+        ? Math.max(...baseEvents.map((e) => e.timestamp))
+        : 0;
+    const oursNewEvents = oursEvents.filter((e) => e.timestamp > baseTimestamp);
+    const theirsNewEvents = theirsEvents.filter((e) => e.timestamp > baseTimestamp);
+    const conflictingEntityIds = new Set();
+    const conflictingFlowIds = new Set();
+    // Analyze entity changes
+    const allEntityIds = new Set([
+        ...oursChanges.entityChanges.keys(),
+        ...theirsChanges.entityChanges.keys(),
+    ]);
+    for (const entityId of allEntityIds) {
+        const oursChange = oursChanges.entityChanges.get(entityId);
+        const theirsChange = theirsChanges.entityChanges.get(entityId);
+        // Only one side changed - no conflict
+        if (!oursChange || !theirsChange) {
+            continue;
+        }
+        // Both sides made the same change
+        if (changesAreIdentical(oursChange, theirsChange)) {
+            autoResolved.push({
+                entityType: oursChange.entityType,
+                entityId,
+                entityName: oursChange.entityName,
+                action: `both-${oursChange.changeType}-identically`,
+            });
+            continue;
+        }
+        // Layout-only changes: auto-resolve with theirs
+        if (isLayoutOnlyChange(oursChange) && isLayoutOnlyChange(theirsChange)) {
+            autoResolved.push({
+                entityType: oursChange.entityType,
+                entityId,
+                entityName: oursChange.entityName,
+                action: 'layout-only-use-theirs',
+            });
+            continue;
+        }
+        // One removed, other modified
+        if ((oursChange.changeType === 'removed' && theirsChange.changeType === 'modified') ||
+            (oursChange.changeType === 'modified' && theirsChange.changeType === 'removed')) {
+            if (strategy) {
+                autoResolved.push({
+                    entityType: oursChange.entityType,
+                    entityId,
+                    entityName: oursChange.entityName,
+                    action: `delete-vs-modify-resolved-${strategy}`,
+                });
+            }
+            else {
+                conflictingEntityIds.add(entityId);
+                conflicts.push({
+                    entityType: oursChange.entityType,
+                    entityId,
+                    entityName: oursChange.entityName,
+                    reason: oursChange.changeType === 'removed'
+                        ? 'Ours deleted, theirs modified'
+                        : 'Ours modified, theirs deleted',
+                    oursValue: oursChange.changeType,
+                    theirsValue: theirsChange.changeType,
+                });
+            }
+            continue;
+        }
+        // Both modified - detailed analysis
+        if (oursChange.changeType === 'modified' && theirsChange.changeType === 'modified') {
+            const analysis = analyzeModificationConflicts(oursChange, theirsChange, strategy);
+            autoResolved.push(...analysis.autoResolved);
+            conflicts.push(...analysis.conflicts);
+            if (analysis.hasHardConflict) {
+                conflictingEntityIds.add(entityId);
+            }
+            continue;
+        }
+        // Both added with same ID
+        if (oursChange.changeType === 'added' && theirsChange.changeType === 'added') {
+            if (strategy) {
+                autoResolved.push({
+                    entityType: oursChange.entityType,
+                    entityId,
+                    entityName: oursChange.entityName,
+                    action: `both-added-resolved-${strategy}`,
+                });
+            }
+            else {
+                conflictingEntityIds.add(entityId);
+                conflicts.push({
+                    entityType: oursChange.entityType,
+                    entityId,
+                    entityName: oursChange.entityName,
+                    reason: 'Both added entity with same ID',
+                    oursValue: oursChange.entityName,
+                    theirsValue: theirsChange.entityName,
+                });
+            }
+        }
+    }
+    // Analyze flow changes
+    const allFlowIds = new Set([
+        ...oursChanges.flowChanges.keys(),
+        ...theirsChanges.flowChanges.keys(),
+    ]);
+    for (const flowId of allFlowIds) {
+        const oursChange = oursChanges.flowChanges.get(flowId);
+        const theirsChange = theirsChanges.flowChanges.get(flowId);
+        if (!oursChange || !theirsChange)
+            continue;
+        // Both added same flow
+        if (oursChange.changeType === 'added' && theirsChange.changeType === 'added') {
+            autoResolved.push({
+                entityType: 'flow',
+                entityId: flowId,
+                entityName: `${oursChange.sourceName} → ${oursChange.targetName}`,
+                action: 'both-added-flow-keep-one',
+            });
+            continue;
+        }
+        // Both removed
+        if (oursChange.changeType === 'removed' && theirsChange.changeType === 'removed') {
+            autoResolved.push({
+                entityType: 'flow',
+                entityId: flowId,
+                entityName: `${oursChange.sourceName} → ${oursChange.targetName}`,
+                action: 'both-removed-identically',
+            });
+            continue;
+        }
+        // One removed, other modified
+        if ((oursChange.changeType === 'removed' && theirsChange.changeType === 'modified') ||
+            (oursChange.changeType === 'modified' && theirsChange.changeType === 'removed')) {
+            if (strategy) {
+                autoResolved.push({
+                    entityType: 'flow',
+                    entityId: flowId,
+                    entityName: `${oursChange.sourceName} → ${oursChange.targetName}`,
+                    action: `flow-delete-vs-modify-resolved-${strategy}`,
+                });
+            }
+            else {
+                conflictingFlowIds.add(flowId);
+                conflicts.push({
+                    entityType: 'flow',
+                    entityId: flowId,
+                    entityName: `${oursChange.sourceName} → ${oursChange.targetName}`,
+                    reason: oursChange.changeType === 'removed'
+                        ? 'Ours removed flow, theirs modified mappings'
+                        : 'Ours modified mappings, theirs removed flow',
+                    oursValue: oursChange.changeType,
+                    theirsValue: theirsChange.changeType,
+                });
+            }
+            continue;
+        }
+        // Both modified mappings
+        if (oursChange.changeType === 'modified' && theirsChange.changeType === 'modified') {
+            if (strategy) {
+                autoResolved.push({
+                    entityType: 'flow',
+                    entityId: flowId,
+                    entityName: `${oursChange.sourceName} → ${oursChange.targetName}`,
+                    action: `flow-mappings-resolved-${strategy}`,
+                });
+            }
+            else {
+                conflictingFlowIds.add(flowId);
+                conflicts.push({
+                    entityType: 'flow',
+                    entityId: flowId,
+                    entityName: `${oursChange.sourceName} → ${oursChange.targetName}`,
+                    reason: 'Both modified flow field mappings',
+                    oursValue: oursChange.mappingChanges,
+                    theirsValue: theirsChange.mappingChanges,
+                });
+            }
+        }
+    }
+    // Build merged events
+    const mergedEvents = [...baseEvents];
+    const affectsConflictingEntity = (event) => {
+        const idFields = [
+            'commandStickyId', 'eventStickyId', 'readModelStickyId',
+            'screenId', 'processorId', 'sliceId', 'chapterId',
+            'aggregateId', 'actorId', 'scenarioId', 'flowId',
+        ];
+        for (const field of idFields) {
+            const id = event[field];
+            if (id && (conflictingEntityIds.has(id) || conflictingFlowIds.has(id))) {
+                return true;
+            }
+        }
+        return false;
+    };
+    // Add non-conflicting events from ours
+    for (const event of oursNewEvents) {
+        if (!affectsConflictingEntity(event)) {
+            mergedEvents.push(event);
+        }
+        else if (strategy === 'ours') {
+            mergedEvents.push(event);
+        }
+    }
+    // Add non-conflicting events from theirs
+    const oursEventKeys = new Set(oursNewEvents.map(e => `${e.type}:${JSON.stringify(e)}`));
+    for (const event of theirsNewEvents) {
+        const eventKey = `${event.type}:${JSON.stringify(event)}`;
+        if (oursEventKeys.has(eventKey))
+            continue;
+        if (!affectsConflictingEntity(event)) {
+            mergedEvents.push(event);
+        }
+        else if (strategy === 'theirs') {
+            mergedEvents.push(event);
+        }
+    }
+    return {
+        success: conflicts.length === 0,
+        conflicts,
+        autoResolved,
+        mergedEvents,
+    };
+}

package/dist/lib/diff/types.d.ts

@@ -0,0 +1,75 @@
+import type { RawEvent, Field } from '../../types.js';
+export type EntityType = 'command' | 'event' | 'readModel' | 'screen' | 'processor' | 'slice' | 'chapter' | 'aggregate' | 'actor' | 'scenario' | 'flow';
+export type ChangeType = 'added' | 'removed' | 'modified';
+export interface FieldChange {
+    fieldPath: string;
+    changeType: ChangeType;
+    oldValue?: Field;
+    newValue?: Field;
+}
+export interface EntityChange {
+    entityType: EntityType;
+    entityId: string;
+    entityName: string;
+    canonicalId?: string;
+    changeType: ChangeType;
+    propertyChanges?: PropertyChange[];
+    fieldChanges?: FieldChange[];
+}
+export interface PropertyChange {
+    property: string;
+    oldValue?: unknown;
+    newValue?: unknown;
+}
+export interface FlowChange {
+    flowId: string;
+    flowType: string;
+    changeType: ChangeType;
+    sourceName?: string;
+    targetName?: string;
+    mappingChanges?: FieldMappingChange[];
+}
+export interface FieldMappingChange {
+    changeType: ChangeType;
+    sourceFieldName?: string;
+    targetFieldName?: string;
+}
+export interface DiffResult {
+    summary: {
+        added: number;
+        removed: number;
+        modified: number;
+    };
+    entityChanges: EntityChange[];
+    flowChanges: FlowChange[];
+}
+export interface MergeConflict {
+    entityType: EntityType;
+    entityId: string;
+    entityName: string;
+    reason: string;
+    property?: string;
+    baseValue?: unknown;
+    oursValue?: unknown;
+    theirsValue?: unknown;
+}
+export interface MergeResult {
+    success: boolean;
+    conflicts: MergeConflict[];
+    autoResolved: AutoResolution[];
+    mergedEvents: RawEvent[];
+}
+export interface AutoResolution {
+    entityType: EntityType;
+    entityId: string;
+    entityName: string;
+    action: string;
+}
+export interface MergeOptions {
+    basePath: string;
+    oursPath: string;
+    theirsPath: string;
+    outputPath: string;
+    strategy?: 'ours' | 'theirs';
+    dryRun?: boolean;
+}

package/dist/lib/diff/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/element-lookup.d.ts

@@ -10,6 +10,15 @@ export type LookupResult<T> = {
     error: 'not_found' | 'ambiguous';
     matches: T[];
 };
+/**
+ * Filter out linked copies from a collection of elements.
+ * Linked copies have `originalNodeId` set and should not be considered
+ * as separate elements for lookup - they're UI conveniences only.
+ */
+export declare function excludeLinkedCopies<T extends {
+    id: string;
+    originalNodeId?: string;
+}>(elements: Map<string, T> | T[]): T[];
 /**
  * Find an element by name (fuzzy) or UUID.
  * - If search starts with "id:", treats rest as UUID/UUID prefix

package/dist/lib/element-lookup.js

@@ -2,6 +2,15 @@
  * Element lookup utilities for CLI commands.
  * Provides fuzzy lookup with UUID disambiguation for ambiguous matches.
  */
+/**
+ * Filter out linked copies from a collection of elements.
+ * Linked copies have `originalNodeId` set and should not be considered
+ * as separate elements for lookup - they're UI conveniences only.
+ */
+export function excludeLinkedCopies(elements) {
+    const elementArray = Array.isArray(elements) ? elements : [...elements.values()];
+    return elementArray.filter(e => !e.originalNodeId);
+}
 /**
  * Normalize a string for fuzzy matching:
  * - lowercase

package/dist/lib/file-loader.d.ts

@@ -3,3 +3,6 @@ export declare function promptForFile(files: string[]): Promise<string>;
 export declare function findEventModelFile(): Promise<string | null>;
 export declare function loadModel(filePath: string): EventModel;
 export declare function appendEvent(filePath: string, event: RawEvent): void;
+export declare function loadRawEvents(filePath: string): RawEvent[];
+export declare function writeEvents(filePath: string, events: RawEvent[]): void;
+export declare function loadModelFromContent(content: string): EventModel;

package/dist/lib/file-loader.js

@@ -51,3 +51,27 @@ export function loadModel(filePath) {
 export function appendEvent(filePath, event) {
     fs.appendFileSync(filePath, JSON.stringify(event) + '\n');
 }
+export function loadRawEvents(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    if (!content.trim()) {
+        return [];
+    }
+    return content
+        .trim()
+        .split('\n')
+        .map(line => JSON.parse(line));
+}
+export function writeEvents(filePath, events) {
+    const content = events.map(e => JSON.stringify(e)).join('\n') + '\n';
+    fs.writeFileSync(filePath, content);
+}
+export function loadModelFromContent(content) {
+    if (!content.trim()) {
+        return projectEvents([]);
+    }
+    const events = content
+        .trim()
+        .split('\n')
+        .map(line => JSON.parse(line));
+    return projectEvents(events);
+}

package/dist/lib/flow-utils.d.ts

@@ -26,6 +26,7 @@ export interface SliceFlowInfo extends FlowInfo {
         name: string;
     };
 }
+export declare function resolveToCanonical(model: EventModel, id: string): string;
 export declare function getElementInfo(model: EventModel, id: string): ElementInfo | null;
 export declare function getSliceComponentIds(model: EventModel, slice: Slice): Set<string>;
 export declare function findSliceForComponent(model: EventModel, componentId: string): Slice | null;