eventmodeler 0.5.0 → 0.6.1

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

@@ -1,390 +0,0 @@
-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.data.timestamp))
-        : 0;
-    const oursNewEvents = oursEvents.filter((e) => e.data.timestamp > baseTimestamp);
-    const theirsNewEvents = theirsEvents.filter((e) => e.data.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.data[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

@@ -1,75 +0,0 @@
-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

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

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

@@ -1,58 +0,0 @@
-/**
- * Element lookup utilities for CLI commands.
- * Provides fuzzy lookup with UUID disambiguation for ambiguous matches.
- */
-export type LookupResult<T> = {
-    success: true;
-    element: T;
-} | {
-    success: false;
-    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
- * - Otherwise, performs fuzzy name matching:
- *   1. Exact match (case-insensitive, normalized spaces)
- *   2. Partial match (search is contained in name)
- * - Returns error if multiple elements match
- */
-export declare function findElement<T extends {
-    id: string;
-    name: string;
-}>(elements: Map<string, T> | T[], search: string): LookupResult<T>;
-/**
- * Format an element name with its ID for display
- */
-export declare function formatElementWithId<T extends {
-    id: string;
-    name: string;
-}>(element: T, truncateId?: boolean): string;
-/**
- * Print error message for lookup failures and exit
- */
-export declare function handleLookupError<T extends {
-    id: string;
-    name: string;
-}>(search: string, elementType: string, result: {
-    success: false;
-    error: 'not_found' | 'ambiguous';
-    matches: T[];
-}, allElements: Map<string, T> | T[]): never;
-/**
- * Convenience function: find element or exit with error
- */
-export declare function findElementOrExit<T extends {
-    id: string;
-    name: string;
-}>(elements: Map<string, T> | T[], search: string, elementType: string): T;

package/dist/lib/element-lookup.js

@@ -1,126 +0,0 @@
-/**
- * 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
- * - collapse multiple spaces to single space
- * - trim whitespace
- */
-function normalize(str) {
-    return str.toLowerCase().replace(/\s+/g, ' ').trim();
-}
-/**
- * Find an element by name (fuzzy) or UUID.
- * - If search starts with "id:", treats rest as UUID/UUID prefix
- * - Otherwise, performs fuzzy name matching:
- *   1. Exact match (case-insensitive, normalized spaces)
- *   2. Partial match (search is contained in name)
- * - Returns error if multiple elements match
- */
-export function findElement(elements, search) {
-    const elementArray = Array.isArray(elements) ? elements : [...elements.values()];
-    // Check for UUID lookup (id:prefix or full UUID format)
-    if (search.startsWith('id:')) {
-        const idSearch = search.slice(3).toLowerCase();
-        const match = elementArray.find(e => e.id.toLowerCase().startsWith(idSearch));
-        if (match) {
-            return { success: true, element: match };
-        }
-        return { success: false, error: 'not_found', matches: [] };
-    }
-    // Check if the search looks like a UUID (contains dashes in UUID pattern)
-    const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (uuidPattern.test(search)) {
-        const match = elementArray.find(e => e.id.toLowerCase() === search.toLowerCase());
-        if (match) {
-            return { success: true, element: match };
-        }
-        return { success: false, error: 'not_found', matches: [] };
-    }
-    const searchNorm = normalize(search);
-    // 1. Try exact match first (case-insensitive, normalized)
-    const exactMatches = elementArray.filter(e => normalize(e.name) === searchNorm);
-    if (exactMatches.length === 1) {
-        return { success: true, element: exactMatches[0] };
-    }
-    if (exactMatches.length > 1) {
-        return { success: false, error: 'ambiguous', matches: exactMatches };
-    }
-    // 2. Try partial match (search contained in name)
-    const partialMatches = elementArray.filter(e => normalize(e.name).includes(searchNorm));
-    if (partialMatches.length === 1) {
-        return { success: true, element: partialMatches[0] };
-    }
-    if (partialMatches.length > 1) {
-        return { success: false, error: 'ambiguous', matches: partialMatches };
-    }
-    // 3. Try word-based match (all search words appear in name)
-    const searchWords = searchNorm.split(' ').filter(w => w.length > 0);
-    const wordMatches = elementArray.filter(e => {
-        const nameNorm = normalize(e.name);
-        return searchWords.every(word => nameNorm.includes(word));
-    });
-    if (wordMatches.length === 1) {
-        return { success: true, element: wordMatches[0] };
-    }
-    if (wordMatches.length > 1) {
-        return { success: false, error: 'ambiguous', matches: wordMatches };
-    }
-    return { success: false, error: 'not_found', matches: [] };
-}
-/**
- * Format an element name with its ID for display
- */
-export function formatElementWithId(element, truncateId = true) {
-    const id = truncateId ? element.id.slice(0, 8) : element.id;
-    return `"${element.name}" (id: ${id})`;
-}
-/**
- * Print error message for lookup failures and exit
- */
-export function handleLookupError(search, elementType, result, allElements) {
-    const elementArray = Array.isArray(allElements) ? allElements : [...allElements.values()];
-    if (result.error === 'ambiguous') {
-        console.error(`Error: Multiple ${elementType}s found with name "${search}"`);
-        console.error('Please specify using the element ID:');
-        for (const el of result.matches) {
-            console.error(`  - ${formatElementWithId(el, false)}`);
-        }
-        console.error('');
-        console.error(`Usage: eventmodeler <command> "id:${result.matches[0].id.slice(0, 8)}"`);
-    }
-    else {
-        console.error(`Error: ${elementType.charAt(0).toUpperCase() + elementType.slice(1)} not found: "${search}"`);
-        if (elementArray.length > 0) {
-            console.error(`Available ${elementType}s:`);
-            for (const el of elementArray) {
-                console.error(`  - ${formatElementWithId(el)}`);
-            }
-        }
-        else {
-            console.error(`No ${elementType}s exist in the model.`);
-        }
-    }
-    process.exit(1);
-}
-/**
- * Convenience function: find element or exit with error
- */
-export function findElementOrExit(elements, search, elementType) {
-    const result = findElement(elements, search);
-    if (!result.success) {
-        handleLookupError(search, elementType, result, elements);
-    }
-    return result.element;
-}

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

@@ -1,8 +0,0 @@
-import type { EventModel, RawEvent } from '../types.js';
-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;