eventmodeler 0.3.2 → 0.3.4

package/dist/index.js

@@ -36,6 +36,9 @@ import { createAutomationSlice } from './slices/create-automation-slice/index.js
 import { createStateViewSlice } from './slices/create-state-view-slice/index.js';
 import { createFlow } from './slices/create-flow/index.js';
 import { codegenSlice } from './slices/codegen-slice/index.js';
+import { diff } from './slices/diff/index.js';
+import { merge } from './slices/merge/index.js';
+import { gitSetup, gitStatus } from './slices/git/index.js';
 const args = process.argv.slice(2);
 function getNamedArg(argList, ...names) {
     for (let i = 0; i < argList.length; i++) {
@@ -109,6 +112,22 @@ COMMANDS:
 
   export json                    Export entire model as JSON
 
+GIT INTEGRATION:
+  git setup                      Configure git to use semantic diff/merge for .eventmodel files
+  git setup --global             Configure globally (for all repos)
+  git status                     Show git integration status
+
+  diff <file1> <file2>           Compare two event model files semantically
+  diff <file> [--ref <gitref>]   Compare working copy against git ref (default: HEAD)
+  diff ... --format text         Human-readable output (default for git)
+  diff ... --format xml|json     Structured output
+
+  merge --base <file> --ours <file> --theirs <file> --output <file>
+                                 Three-way merge of event model files
+  merge ... --strategy ours|theirs
+                                 Auto-resolve conflicts with given strategy
+  merge ... --dry-run            Show conflicts without writing output
+
 OPTIONS:
   -f, --file <path>              Path to .eventmodel file (default: auto-detect)
   --format <xml|json>            Output format (default: xml, or from config)
@@ -174,6 +193,83 @@ async function main() {
         openApp();
         return;
     }
+    // Handle diff and merge commands separately (they manage their own file loading)
+    if (command === 'diff') {
+        const baseArg = getNamedArg(filteredArgs, '--base');
+        const compareArg = getNamedArg(filteredArgs, '--compare');
+        const refArg = getNamedArg(filteredArgs, '--ref');
+        // Diff supports 'text' format in addition to xml/json
+        const diffFormat = formatArg === 'json' ? 'json'
+            : formatArg === 'xml' ? 'xml'
+                : formatArg === 'text' ? 'text'
+                    : 'text'; // Default to text for human-readable output
+        // Two-file mode: diff file1 file2 OR diff --base file1 --compare file2
+        if (baseArg && compareArg) {
+            diff(baseArg, compareArg, diffFormat);
+            return;
+        }
+        // Positional args: diff file1 file2
+        const file1 = filteredArgs[1];
+        const file2 = filteredArgs[2];
+        if (file1 && file2 && !file1.startsWith('--') && !file2.startsWith('--')) {
+            diff(file1, file2, diffFormat);
+            return;
+        }
+        // Single file mode: diff file [--ref HEAD]
+        if (file1 && !file1.startsWith('--')) {
+            diff(file1, undefined, diffFormat, refArg);
+            return;
+        }
+        console.error('Usage: eventmodeler diff <file1> <file2>');
+        console.error('       eventmodeler diff <file> [--ref <gitref>]');
+        console.error('       eventmodeler diff --base <file> --compare <file>');
+        process.exit(1);
+    }
+    if (command === 'merge') {
+        const baseArg = getNamedArg(filteredArgs, '--base');
+        const oursArg = getNamedArg(filteredArgs, '--ours');
+        const theirsArg = getNamedArg(filteredArgs, '--theirs');
+        const outputArg = getNamedArg(filteredArgs, '--output');
+        const strategyArg = getNamedArg(filteredArgs, '--strategy');
+        const dryRun = filteredArgs.includes('--dry-run');
+        if (!baseArg || !oursArg || !theirsArg) {
+            console.error('Usage: eventmodeler merge --base <file> --ours <file> --theirs <file> --output <file>');
+            console.error('Options:');
+            console.error('  --strategy ours|theirs    Auto-resolve conflicts');
+            console.error('  --dry-run                 Show result without writing');
+            process.exit(1);
+        }
+        if (!outputArg && !dryRun) {
+            console.error('Error: --output is required (or use --dry-run)');
+            process.exit(1);
+        }
+        merge({
+            basePath: baseArg,
+            oursPath: oursArg,
+            theirsPath: theirsArg,
+            outputPath: outputArg ?? '',
+            strategy: strategyArg === 'ours' || strategyArg === 'theirs' ? strategyArg : undefined,
+            dryRun,
+            format,
+        });
+        return;
+    }
+    if (command === 'git') {
+        const gitCommand = filteredArgs[1];
+        const globalFlag = filteredArgs.includes('--global');
+        switch (gitCommand) {
+            case 'setup':
+                gitSetup(globalFlag);
+                return;
+            case 'status':
+                gitStatus();
+                return;
+            default:
+                console.error('Usage: eventmodeler git setup [--global]');
+                console.error('       eventmodeler git status');
+                process.exit(1);
+        }
+    }
     const filePath = fileArg ?? await findEventModelFile();
     if (!filePath) {
         console.error('Error: No .eventmodel file found in current directory.');

package/dist/lib/diff/merge-rules.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Merge rules for Event Model conflicts.
+ *
+ * Based on analysis of user workflows, these rules define how to handle
+ * different types of conflicts when merging two branches.
+ */
+import type { EntityChange, FieldChange } from './types.js';
+export type ConflictResolution = {
+    type: 'auto';
+    action: string;
+} | {
+    type: 'soft';
+    reason: string;
+} | {
+    type: 'hard';
+    reason: string;
+};
+/**
+ * Determine how to resolve a property conflict.
+ */
+export declare function resolvePropertyConflict(property: string, oursValue: unknown, theirsValue: unknown, entityType: string): ConflictResolution;
+/**
+ * Determine how to resolve a field conflict.
+ */
+export declare function resolveFieldConflict(oursChange: FieldChange, theirsChange: FieldChange): ConflictResolution;
+/**
+ * Merge two arrays (e.g., nodeIds) removing duplicates.
+ */
+export declare function mergeArrays<T>(base: T[], ours: T[], theirs: T[]): T[];
+/**
+ * Check if an entity change affects only layout properties.
+ */
+export declare function isLayoutOnlyChange(change: EntityChange): boolean;
+/**
+ * Categorize fields changes for merge.
+ */
+export declare function categorizeFieldChanges(oursChanges: FieldChange[], theirsChanges: FieldChange[]): {
+    oursOnly: FieldChange[];
+    theirsOnly: FieldChange[];
+    conflicts: Array<{
+        ours: FieldChange;
+        theirs: FieldChange;
+        resolution: ConflictResolution;
+    }>;
+};

package/dist/lib/diff/merge-rules.js

@@ -0,0 +1,210 @@
+/**
+ * Merge rules for Event Model conflicts.
+ *
+ * Based on analysis of user workflows, these rules define how to handle
+ * different types of conflicts when merging two branches.
+ */
+/**
+ * Slice status priority order.
+ * Higher priority wins in auto-resolution.
+ */
+const SLICE_STATUS_PRIORITY = {
+    'done': 4,
+    'in-progress': 3,
+    'blocked': 2,
+    'created': 1,
+};
+/**
+ * Properties that can be auto-resolved with last-write-wins.
+ * These are layout/visual properties that don't affect semantics.
+ */
+const LAYOUT_PROPERTIES = new Set([
+    'position',
+    'width',
+    'height',
+    'size',
+    'x',
+    'y',
+]);
+/**
+ * Determine how to resolve a property conflict.
+ */
+export function resolvePropertyConflict(property, oursValue, theirsValue, entityType) {
+    // Layout properties: auto-resolve with theirs (last-write-wins)
+    if (LAYOUT_PROPERTIES.has(property)) {
+        return { type: 'auto', action: 'layout-use-theirs' };
+    }
+    // Slice status: use priority order
+    if (property === 'status' && entityType === 'slice') {
+        const oursPriority = SLICE_STATUS_PRIORITY[oursValue] ?? 0;
+        const theirsPriority = SLICE_STATUS_PRIORITY[theirsValue] ?? 0;
+        if (oursPriority >= theirsPriority) {
+            return { type: 'auto', action: 'status-priority-ours' };
+        }
+        else {
+            return { type: 'auto', action: 'status-priority-theirs' };
+        }
+    }
+    // Name conflicts: hard conflict
+    if (property === 'name') {
+        return { type: 'hard', reason: `Both renamed to different values` };
+    }
+    // nodeIds/eventIds/screenIds: can merge (include both)
+    if (property === 'nodeIds' || property === 'eventIds' || property === 'screenIds') {
+        return { type: 'auto', action: 'merge-arrays' };
+    }
+    // Scenario parts: hard conflict
+    if (property === 'givenEvents' || property === 'whenCommand' || property === 'then' || property === 'description') {
+        return { type: 'hard', reason: `Both modified ${property}` };
+    }
+    // Default: hard conflict
+    return { type: 'hard', reason: `Both modified ${property}` };
+}
+/**
+ * Determine how to resolve a field conflict.
+ */
+export function resolveFieldConflict(oursChange, theirsChange) {
+    const fieldPath = oursChange.fieldPath;
+    // Both added same field
+    if (oursChange.changeType === 'added' && theirsChange.changeType === 'added') {
+        const oursField = oursChange.newValue;
+        const theirsField = theirsChange.newValue;
+        // Same type: auto-resolve (keep one)
+        if (oursField && theirsField && fieldsCompatible(oursField, theirsField)) {
+            return { type: 'auto', action: 'both-added-compatible' };
+        }
+        // Different types: hard conflict
+        return { type: 'hard', reason: `Both added field "${fieldPath}" with different types` };
+    }
+    // Both removed same field
+    if (oursChange.changeType === 'removed' && theirsChange.changeType === 'removed') {
+        return { type: 'auto', action: 'both-removed' };
+    }
+    // One removed, other modified
+    if ((oursChange.changeType === 'removed' && theirsChange.changeType === 'modified') ||
+        (oursChange.changeType === 'modified' && theirsChange.changeType === 'removed')) {
+        return { type: 'hard', reason: `Field "${fieldPath}": one removed, other modified` };
+    }
+    // Both modified same field
+    if (oursChange.changeType === 'modified' && theirsChange.changeType === 'modified') {
+        const oursField = oursChange.newValue;
+        const theirsField = theirsChange.newValue;
+        // Same change: auto-resolve
+        if (oursField && theirsField && fieldsEqual(oursField, theirsField)) {
+            return { type: 'auto', action: 'both-modified-identically' };
+        }
+        // Different changes: hard conflict
+        return { type: 'hard', reason: `Both modified field "${fieldPath}" differently` };
+    }
+    return { type: 'hard', reason: `Unexpected field conflict on "${fieldPath}"` };
+}
+/**
+ * Check if two fields are semantically equal.
+ */
+function fieldsEqual(a, b) {
+    if (a.name !== b.name)
+        return false;
+    if (a.fieldType !== b.fieldType)
+        return false;
+    if (a.isList !== b.isList)
+        return false;
+    if (a.isGenerated !== b.isGenerated)
+        return false;
+    if (a.isOptional !== b.isOptional)
+        return false;
+    if (a.isUserInput !== b.isUserInput)
+        return false;
+    // Compare subfields
+    const aSubfields = a.subfields ?? [];
+    const bSubfields = b.subfields ?? [];
+    if (aSubfields.length !== bSubfields.length)
+        return false;
+    for (let i = 0; i < aSubfields.length; i++) {
+        if (!fieldsEqual(aSubfields[i], bSubfields[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * Check if two fields are compatible (can be merged).
+ * Compatible means same name and type, even if other properties differ.
+ */
+function fieldsCompatible(a, b) {
+    if (a.name !== b.name)
+        return false;
+    if (a.fieldType !== b.fieldType)
+        return false;
+    if (a.isList !== b.isList)
+        return false;
+    return true;
+}
+/**
+ * Merge two arrays (e.g., nodeIds) removing duplicates.
+ */
+export function mergeArrays(base, ours, theirs) {
+    const baseSet = new Set(base);
+    const result = new Set(base);
+    // Add items from ours that weren't in base
+    for (const item of ours) {
+        if (!baseSet.has(item)) {
+            result.add(item);
+        }
+    }
+    // Add items from theirs that weren't in base
+    for (const item of theirs) {
+        if (!baseSet.has(item)) {
+            result.add(item);
+        }
+    }
+    // Remove items deleted in ours
+    for (const item of base) {
+        if (!ours.includes(item)) {
+            result.delete(item);
+        }
+    }
+    // Remove items deleted in theirs
+    for (const item of base) {
+        if (!theirs.includes(item)) {
+            result.delete(item);
+        }
+    }
+    return [...result];
+}
+/**
+ * Check if an entity change affects only layout properties.
+ */
+export function isLayoutOnlyChange(change) {
+    if (change.changeType !== 'modified')
+        return false;
+    if (change.fieldChanges && change.fieldChanges.length > 0)
+        return false;
+    if (!change.propertyChanges)
+        return true;
+    return change.propertyChanges.every(p => LAYOUT_PROPERTIES.has(p.property));
+}
+/**
+ * Categorize fields changes for merge.
+ */
+export function categorizeFieldChanges(oursChanges, theirsChanges) {
+    const oursMap = new Map(oursChanges.map(c => [c.fieldPath, c]));
+    const theirsMap = new Map(theirsChanges.map(c => [c.fieldPath, c]));
+    const oursOnly = [];
+    const theirsOnly = [];
+    const conflicts = [];
+    for (const [path, oursChange] of oursMap) {
+        const theirsChange = theirsMap.get(path);
+        if (theirsChange) {
+            const resolution = resolveFieldConflict(oursChange, theirsChange);
+            conflicts.push({ ours: oursChange, theirs: theirsChange, resolution });
+        }
+        else {
+            oursOnly.push(oursChange);
+        }
+    }
+    for (const [path, theirsChange] of theirsMap) {
+        if (!oursMap.has(path)) {
+            theirsOnly.push(theirsChange);
+        }
+    }
+    return { oursOnly, theirsOnly, conflicts };
+}

package/dist/lib/diff/model-differ.d.ts

@@ -0,0 +1,8 @@
+import type { EventModel } from '../../types.js';
+import type { DiffResult, EntityChange, FieldChange, FlowChange } from './types.js';
+/**
+ * Compare two EventModels and return semantic differences.
+ * Ignores layout properties (position, size) and linked copies.
+ */
+export declare function diffModels(baseModel: EventModel, compareModel: EventModel): DiffResult;
+export type { DiffResult, EntityChange, FieldChange, FlowChange };