eventmodeler 0.5.0 → 0.6.0

package/dist/slices/list-scenarios/index.js

@@ -1,35 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-export function listScenarios(model, format) {
-    const scenarios = [...model.scenarios.values()];
-    const sorted = [...scenarios].sort((a, b) => a.name.localeCompare(b.name));
-    if (format === 'json') {
-        outputJson({
-            scenarios: sorted.map(scenario => {
-                const slice = model.slices.get(scenario.sliceId);
-                const result = {
-                    id: scenario.id,
-                    name: scenario.name,
-                    slice: slice?.name ?? scenario.sliceId,
-                    thenType: scenario.then.type
-                };
-                if (scenario.description) {
-                    result.description = scenario.description;
-                }
-                return result;
-            })
-        });
-        return;
-    }
-    if (scenarios.length === 0) {
-        console.log('<scenarios/>');
-        return;
-    }
-    console.log('<scenarios>');
-    for (const scenario of sorted) {
-        const slice = model.slices.get(scenario.sliceId);
-        const sliceName = slice?.name ?? scenario.sliceId;
-        const descAttr = scenario.description ? ` description="${escapeXml(scenario.description)}"` : '';
-        console.log(`  <scenario id="${scenario.id}" name="${escapeXml(scenario.name)}" slice="${escapeXml(sliceName)}" then-type="${scenario.then.type}"${descAttr}/>`);
-    }
-    console.log('</scenarios>');
-}

package/dist/slices/list-screens/index.d.ts

@@ -1,3 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function listScreens(model: EventModel, format: OutputFormat): void;

package/dist/slices/list-screens/index.js

@@ -1,47 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-// Get the actor name for a screen based on spatial containment
-function getActorForScreen(model, screen) {
-    const centerX = screen.position.x + screen.width / 2;
-    const centerY = screen.position.y + screen.height / 2;
-    for (const actor of model.actors.values()) {
-        const bounds = {
-            left: actor.position.x,
-            right: actor.position.x + actor.size.width,
-            top: actor.position.y,
-            bottom: actor.position.y + actor.size.height,
-        };
-        if (centerX >= bounds.left && centerX <= bounds.right &&
-            centerY >= bounds.top && centerY <= bounds.bottom) {
-            return actor.name;
-        }
-    }
-    return undefined;
-}
-export function listScreens(model, format) {
-    // Filter out linked copies (they have originalNodeId set)
-    const screens = [...model.screens.values()].filter(scr => !scr.originalNodeId);
-    const sorted = [...screens].sort((a, b) => a.name.localeCompare(b.name));
-    if (format === 'json') {
-        outputJson({
-            screens: sorted.map(scr => {
-                const result = { id: scr.id, name: scr.name, fields: scr.fields.length };
-                const actor = getActorForScreen(model, scr);
-                if (actor)
-                    result.actor = actor;
-                return result;
-            })
-        });
-        return;
-    }
-    if (screens.length === 0) {
-        console.log('<screens/>');
-        return;
-    }
-    console.log('<screens>');
-    for (const scr of sorted) {
-        const actor = getActorForScreen(model, scr);
-        const actorAttr = actor ? ` actor="${escapeXml(actor)}"` : '';
-        console.log(`  <screen id="${scr.id}" name="${escapeXml(scr.name)}" fields="${scr.fields.length}"${actorAttr}/>`);
-    }
-    console.log('</screens>');
-}

package/dist/slices/list-slices/index.d.ts

@@ -1,3 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function listSlices(model: EventModel, format: OutputFormat, chapterName?: string): void;

package/dist/slices/list-slices/index.js

@@ -1,35 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-function getSlicesUnderChapter(model, chapter) {
-    const chapterLeft = chapter.position.x;
-    const chapterRight = chapter.position.x + chapter.size.width;
-    return [...model.slices.values()].filter(slice => {
-        const sliceCenterX = slice.position.x + slice.size.width / 2;
-        return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
-    });
-}
-export function listSlices(model, format, chapterName) {
-    let slices = [...model.slices.values()];
-    // Filter by chapter if specified
-    if (chapterName) {
-        const chapter = findElementOrExit(model.chapters, chapterName, 'chapter');
-        slices = getSlicesUnderChapter(model, chapter);
-    }
-    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
-    if (format === 'json') {
-        outputJson({
-            ...(chapterName && { chapter: chapterName }),
-            slices: sorted.map(s => ({ id: s.id, name: s.name, status: s.status }))
-        });
-        return;
-    }
-    if (slices.length === 0) {
-        console.log('<slices/>');
-        return;
-    }
-    console.log('<slices>');
-    for (const slice of sorted) {
-        console.log(`  <slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
-    }
-    console.log('</slices>');
-}

package/dist/slices/login/index.d.ts

@@ -1 +0,0 @@
-export declare function login(): Promise<void>;

package/dist/slices/logout/index.d.ts

@@ -1 +0,0 @@
-export declare function logout(): void;

package/dist/slices/map-fields/index.d.ts

@@ -1,2 +0,0 @@
-import type { EventModel } from '../../types.js';
-export declare function mapFields(model: EventModel, filePath: string, flowIdentifier: string, input: string): void;

package/dist/slices/map-fields/index.js

@@ -1,269 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-/**
- * Resolves an entity ID to its canonical original.
- * If the entity is a linked copy, returns the original's ID.
- * Otherwise returns the entity ID unchanged.
- */
-function resolveToOriginal(model, entityId) {
-    const event = model.events.get(entityId);
-    if (event?.originalNodeId)
-        return event.originalNodeId;
-    const readModel = model.readModels.get(entityId);
-    if (readModel?.originalNodeId)
-        return readModel.originalNodeId;
-    const screen = model.screens.get(entityId);
-    if (screen?.originalNodeId)
-        return screen.originalNodeId;
-    return entityId;
-}
-/**
- * Checks if an entity is a linked copy (has originalNodeId set).
- */
-function isLinkedCopy(model, entityId) {
-    const event = model.events.get(entityId);
-    if (event?.originalNodeId)
-        return true;
-    const readModel = model.readModels.get(entityId);
-    if (readModel?.originalNodeId)
-        return true;
-    const screen = model.screens.get(entityId);
-    if (screen?.originalNodeId)
-        return true;
-    return false;
-}
-function flattenFields(fields, prefix = '') {
-    const result = [];
-    for (const field of fields) {
-        const path = prefix ? `${prefix}.${field.name}` : field.name;
-        result.push({ id: field.id, path, field });
-        if (field.fieldType === 'Custom' && field.subfields) {
-            result.push(...flattenFields(field.subfields, path));
-        }
-    }
-    return result;
-}
-function parseJsonInput(input) {
-    const parsed = JSON.parse(input);
-    if (!Array.isArray(parsed)) {
-        return [parsed];
-    }
-    return parsed;
-}
-function parseXmlInput(input) {
-    const mappings = [];
-    const mappingMatches = input.matchAll(/<mapping[^>]*from="([^"]*)"[^>]*to="([^"]*)"[^>]*\/?>/g);
-    for (const match of mappingMatches) {
-        mappings.push({ from: match[1], to: match[2] });
-    }
-    // Also try alternate attribute order
-    const altMatches = input.matchAll(/<mapping[^>]*to="([^"]*)"[^>]*from="([^"]*)"[^>]*\/?>/g);
-    for (const match of altMatches) {
-        // Check if this mapping was already added
-        const exists = mappings.some(m => m.from === match[2] && m.to === match[1]);
-        if (!exists) {
-            mappings.push({ from: match[2], to: match[1] });
-        }
-    }
-    if (mappings.length === 0) {
-        throw new Error('No <mapping from="..." to="..."/> elements found in XML');
-    }
-    return mappings;
-}
-function parseInput(input) {
-    const trimmed = input.trim();
-    if (trimmed.startsWith('<')) {
-        return parseXmlInput(trimmed);
-    }
-    return parseJsonInput(trimmed);
-}
-export function mapFields(model, filePath, flowIdentifier, input) {
-    // Parse the mapping input
-    let mappingInputs;
-    try {
-        mappingInputs = parseInput(input);
-    }
-    catch (err) {
-        console.error(`Error: Invalid input format: ${err.message}`);
-        process.exit(1);
-    }
-    // Find the flow - can be identified by:
-    // 1. Flow ID directly
-    // 2. "SourceName→TargetName" format (using → or ->)
-    let flow = model.flows.get(flowIdentifier);
-    if (!flow) {
-        // Try to parse as "Source→Target" or "Source->Target"
-        const arrowMatch = flowIdentifier.match(/^(.+?)(?:→|->)(.+)$/);
-        if (arrowMatch) {
-            const sourceName = arrowMatch[1].trim().toLowerCase();
-            const targetName = arrowMatch[2].trim().toLowerCase();
-            // Find matching flow, preferring flows that don't involve linked copies
-            let fallbackFlow = undefined;
-            for (const f of model.flows.values()) {
-                let sourceEntityName = '';
-                let targetEntityName = '';
-                // Get source name
-                const sourceEvent = model.events.get(f.sourceId);
-                const sourceReadModel = model.readModels.get(f.sourceId);
-                const sourceScreen = model.screens.get(f.sourceId);
-                const sourceProcessor = model.processors.get(f.sourceId);
-                const sourceCommand = model.commands.get(f.sourceId);
-                if (sourceEvent)
-                    sourceEntityName = sourceEvent.name.toLowerCase();
-                else if (sourceReadModel)
-                    sourceEntityName = sourceReadModel.name.toLowerCase();
-                else if (sourceScreen)
-                    sourceEntityName = sourceScreen.name.toLowerCase();
-                else if (sourceProcessor)
-                    sourceEntityName = sourceProcessor.name.toLowerCase();
-                else if (sourceCommand)
-                    sourceEntityName = sourceCommand.name.toLowerCase();
-                // Get target name
-                const targetEvent = model.events.get(f.targetId);
-                const targetReadModel = model.readModels.get(f.targetId);
-                const targetScreen = model.screens.get(f.targetId);
-                const targetProcessor = model.processors.get(f.targetId);
-                const targetCommand = model.commands.get(f.targetId);
-                if (targetEvent)
-                    targetEntityName = targetEvent.name.toLowerCase();
-                else if (targetReadModel)
-                    targetEntityName = targetReadModel.name.toLowerCase();
-                else if (targetScreen)
-                    targetEntityName = targetScreen.name.toLowerCase();
-                else if (targetProcessor)
-                    targetEntityName = targetProcessor.name.toLowerCase();
-                else if (targetCommand)
-                    targetEntityName = targetCommand.name.toLowerCase();
-                // Check for match (exact or partial)
-                const sourceMatches = sourceEntityName === sourceName || sourceEntityName.includes(sourceName);
-                const targetMatches = targetEntityName === targetName || targetEntityName.includes(targetName);
-                if (sourceMatches && targetMatches) {
-                    // Prefer flows that don't involve linked copies
-                    const involvesLinkedCopy = isLinkedCopy(model, f.sourceId) || isLinkedCopy(model, f.targetId);
-                    if (!involvesLinkedCopy) {
-                        flow = f;
-                        break;
-                    }
-                    else if (!fallbackFlow) {
-                        // Keep as fallback in case no non-copy flow is found
-                        fallbackFlow = f;
-                    }
-                }
-            }
-            // Use fallback if no non-copy flow was found
-            if (!flow && fallbackFlow) {
-                flow = fallbackFlow;
-            }
-        }
-    }
-    if (!flow) {
-        console.error(`Error: Flow not found: ${flowIdentifier}`);
-        console.error('Available flows:');
-        for (const f of model.flows.values()) {
-            // Skip flows where source or target is a linked copy (UI-only elements)
-            if (isLinkedCopy(model, f.sourceId) || isLinkedCopy(model, f.targetId)) {
-                continue;
-            }
-            const source = getEntityName(model, f.sourceId);
-            const target = getEntityName(model, f.targetId);
-            console.error(`  - ${source}→${target} (${f.id})`);
-        }
-        process.exit(1);
-    }
-    // Get source and target fields
-    const sourceFields = getEntityFields(model, flow.sourceId);
-    const targetFields = getEntityFields(model, flow.targetId);
-    const flatSource = flattenFields(sourceFields);
-    const flatTarget = flattenFields(targetFields);
-    // Resolve mapping inputs to field IDs
-    const mappings = [];
-    for (const m of mappingInputs) {
-        // Find source field (by name/path or ID)
-        const sourceField = flatSource.find(sf => sf.id === m.from || sf.path.toLowerCase() === m.from.toLowerCase());
-        if (!sourceField) {
-            console.error(`Error: Source field not found: ${m.from}`);
-            console.error('Available source fields:');
-            for (const sf of flatSource) {
-                console.error(`  - ${sf.path} (${sf.id})`);
-            }
-            process.exit(1);
-        }
-        // Find target field (by name/path or ID)
-        const targetField = flatTarget.find(tf => tf.id === m.to || tf.path.toLowerCase() === m.to.toLowerCase());
-        if (!targetField) {
-            console.error(`Error: Target field not found: ${m.to}`);
-            console.error('Available target fields:');
-            for (const tf of flatTarget) {
-                console.error(`  - ${tf.path} (${tf.id})`);
-            }
-            process.exit(1);
-        }
-        mappings.push({
-            sourceFieldId: sourceField.id,
-            targetFieldId: targetField.id,
-        });
-    }
-    // Get existing mappings and merge
-    const existingMappings = flow.fieldMappings ?? [];
-    const mergedMappings = [...existingMappings];
-    for (const newMapping of mappings) {
-        // Remove any existing mapping for the same target field
-        const existingIndex = mergedMappings.findIndex(m => m.targetFieldId === newMapping.targetFieldId);
-        if (existingIndex >= 0) {
-            mergedMappings.splice(existingIndex, 1);
-        }
-        mergedMappings.push(newMapping);
-    }
-    // Append the event
-    appendEvent(filePath, {
-        type: 'FieldMappingSpecified',
-        data: {
-            flowId: flow.id,
-            mappings: mergedMappings,
-            timestamp: Date.now(),
-        },
-    });
-    const sourceName = getEntityName(model, flow.sourceId);
-    const targetName = getEntityName(model, flow.targetId);
-    console.log(`Mapped ${mappings.length} field(s) on flow ${sourceName}→${targetName}`);
-    for (const m of mappingInputs) {
-        console.log(`  ${m.from} → ${m.to}`);
-    }
-}
-function getEntityName(model, entityId) {
-    const event = model.events.get(entityId);
-    if (event)
-        return event.name;
-    const readModel = model.readModels.get(entityId);
-    if (readModel)
-        return readModel.name;
-    const command = model.commands.get(entityId);
-    if (command)
-        return command.name;
-    const screen = model.screens.get(entityId);
-    if (screen)
-        return screen.name;
-    const processor = model.processors.get(entityId);
-    if (processor)
-        return processor.name;
-    return entityId;
-}
-function getEntityFields(model, entityId) {
-    // Resolve linked copies to their originals to get canonical fields
-    const resolvedId = resolveToOriginal(model, entityId);
-    const event = model.events.get(resolvedId);
-    if (event)
-        return event.fields;
-    const readModel = model.readModels.get(resolvedId);
-    if (readModel)
-        return readModel.fields;
-    const command = model.commands.get(resolvedId);
-    if (command)
-        return command.fields;
-    const screen = model.screens.get(resolvedId);
-    if (screen)
-        return screen.fields;
-    const processor = model.processors.get(resolvedId);
-    if (processor)
-        return processor.fields;
-    return [];
-}

package/dist/slices/mark-slice-status/index.d.ts

@@ -1,2 +0,0 @@
-import type { EventModel } from '../../types.js';
-export declare function markSliceStatus(model: EventModel, filePath: string, sliceName: string, status: string): void;

package/dist/slices/mark-slice-status/index.js

@@ -1,31 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-const validStatuses = ['created', 'in-progress', 'blocked', 'done'];
-const eventTypeMap = {
-    'created': 'SliceMarkedAsCreated',
-    'in-progress': 'SliceMarkedAsInProgress',
-    'blocked': 'SliceMarkedAsBlocked',
-    'done': 'SliceMarkedAsDone',
-};
-export function markSliceStatus(model, filePath, sliceName, status) {
-    if (!validStatuses.includes(status)) {
-        console.error(`Error: Invalid status: ${status}`);
-        console.error('Valid statuses: created, in-progress, blocked, done');
-        process.exit(1);
-    }
-    const newStatus = status;
-    const slice = findElementOrExit(model.slices, sliceName, 'slice');
-    if (slice.status === newStatus) {
-        console.log(`Slice "${slice.name}" is already marked as ${newStatus}`);
-        return;
-    }
-    const event = {
-        type: eventTypeMap[newStatus],
-        data: {
-            sliceId: slice.id,
-            timestamp: Date.now(),
-        },
-    };
-    appendEvent(filePath, event);
-    console.log(`Marked slice "${slice.name}" as ${newStatus}`);
-}

package/dist/slices/merge/index.d.ts

@@ -1,19 +0,0 @@
-import type { OutputFormat } from '../../lib/format.js';
-export interface MergeOptions {
-    basePath: string;
-    oursPath: string;
-    theirsPath: string;
-    outputPath: string;
-    strategy?: 'ours' | 'theirs';
-    dryRun: boolean;
-    format: OutputFormat;
-}
-/**
- * Three-way merge of eventmodel files.
- *
- * Exit codes:
- *   0 - Clean merge (success)
- *   1 - Conflicts detected
- *   2 - Error (file not found, parse error)
- */
-export declare function merge(options: MergeOptions): void;

package/dist/slices/merge/index.js

@@ -1,147 +0,0 @@
-import * as fs from 'node:fs';
-import { loadModel, loadRawEvents, writeEvents } from '../../lib/file-loader.js';
-import { threeWayMerge } from '../../lib/diff/three-way-merge.js';
-import { escapeXml, outputJson } from '../../lib/format.js';
-function formatConflictXml(conflict) {
-    const lines = [];
-    const entityAttr = escapeXml(conflict.entityType);
-    const nameAttr = escapeXml(conflict.entityName);
-    const idAttr = escapeXml(conflict.entityId);
-    lines.push(`    <conflict entity="${entityAttr}" name="${nameAttr}" id="${idAttr}">`);
-    lines.push(`      <reason>${escapeXml(conflict.reason)}</reason>`);
-    if (conflict.baseValue !== undefined) {
-        lines.push(`      <base>${escapeXml(JSON.stringify(conflict.baseValue))}</base>`);
-    }
-    if (conflict.oursValue !== undefined) {
-        lines.push(`      <ours>${escapeXml(JSON.stringify(conflict.oursValue))}</ours>`);
-    }
-    if (conflict.theirsValue !== undefined) {
-        lines.push(`      <theirs>${escapeXml(JSON.stringify(conflict.theirsValue))}</theirs>`);
-    }
-    lines.push('    </conflict>');
-    return lines.join('\n');
-}
-function formatAutoResolutionXml(resolution) {
-    const entityAttr = escapeXml(resolution.entityType);
-    const nameAttr = escapeXml(resolution.entityName);
-    const actionAttr = escapeXml(resolution.action);
-    return `    <resolution entity="${entityAttr}" name="${nameAttr}" action="${actionAttr}"/>`;
-}
-function formatMergeResultXml(result, dryRun) {
-    const lines = [];
-    const status = result.success ? 'success' : 'conflicts';
-    lines.push(`<merge-result status="${status}">`);
-    lines.push(`  <summary merged-events="${result.mergedEvents.length}" conflicts="${result.conflicts.length}" auto-resolved="${result.autoResolved.length}"/>`);
-    if (result.conflicts.length > 0) {
-        lines.push('  <conflicts>');
-        for (const conflict of result.conflicts) {
-            lines.push(formatConflictXml(conflict));
-        }
-        lines.push('  </conflicts>');
-    }
-    if (result.autoResolved.length > 0) {
-        lines.push('  <auto-resolved>');
-        for (const resolution of result.autoResolved) {
-            lines.push(formatAutoResolutionXml(resolution));
-        }
-        lines.push('  </auto-resolved>');
-    }
-    if (dryRun) {
-        lines.push('  <note>Dry run - no files were modified</note>');
-    }
-    lines.push('</merge-result>');
-    return lines.join('\n');
-}
-function formatMergeResultJson(result, dryRun) {
-    return {
-        success: result.success,
-        summary: {
-            mergedEvents: result.mergedEvents.length,
-            conflicts: result.conflicts.length,
-            autoResolved: result.autoResolved.length,
-        },
-        conflicts: result.conflicts.map((c) => ({
-            entityType: c.entityType,
-            entityId: c.entityId,
-            entityName: c.entityName,
-            reason: c.reason,
-            property: c.property,
-            base: c.baseValue,
-            ours: c.oursValue,
-            theirs: c.theirsValue,
-        })),
-        autoResolved: result.autoResolved.map((r) => ({
-            entityType: r.entityType,
-            entityId: r.entityId,
-            entityName: r.entityName,
-            action: r.action,
-        })),
-        dryRun,
-    };
-}
-/**
- * Three-way merge of eventmodel files.
- *
- * Exit codes:
- *   0 - Clean merge (success)
- *   1 - Conflicts detected
- *   2 - Error (file not found, parse error)
- */
-export function merge(options) {
-    const { basePath, oursPath, theirsPath, outputPath, strategy, dryRun, format } = options;
-    // Validate files exist
-    if (!fs.existsSync(basePath)) {
-        console.error(`Error: Base file not found: ${basePath}`);
-        process.exit(2);
-    }
-    if (!fs.existsSync(oursPath)) {
-        console.error(`Error: Ours file not found: ${oursPath}`);
-        process.exit(2);
-    }
-    if (!fs.existsSync(theirsPath)) {
-        console.error(`Error: Theirs file not found: ${theirsPath}`);
-        process.exit(2);
-    }
-    // Load models and raw events
-    let baseModel, oursModel, theirsModel;
-    let baseEvents, oursEvents, theirsEvents;
-    try {
-        baseModel = loadModel(basePath);
-        oursModel = loadModel(oursPath);
-        theirsModel = loadModel(theirsPath);
-        baseEvents = loadRawEvents(basePath);
-        oursEvents = loadRawEvents(oursPath);
-        theirsEvents = loadRawEvents(theirsPath);
-    }
-    catch (err) {
-        console.error(`Error parsing eventmodel files: ${err.message}`);
-        process.exit(2);
-    }
-    // Perform merge
-    const result = threeWayMerge(baseModel, oursModel, theirsModel, baseEvents, oursEvents, theirsEvents, strategy);
-    // Output result
-    if (format === 'json') {
-        outputJson(formatMergeResultJson(result, dryRun));
-    }
-    else {
-        console.log(formatMergeResultXml(result, dryRun));
-    }
-    // Write merged file if not dry run and successful (or strategy provided)
-    if (!dryRun && (result.success || strategy)) {
-        try {
-            writeEvents(outputPath, result.mergedEvents);
-            console.error(`Merged ${result.mergedEvents.length} events to ${outputPath}`);
-        }
-        catch (err) {
-            console.error(`Error writing output file: ${err.message}`);
-            process.exit(2);
-        }
-    }
-    // Exit with appropriate code
-    if (result.success) {
-        process.exit(0);
-    }
-    else {
-        process.exit(1);
-    }
-}

package/dist/slices/open-app/index.d.ts

@@ -1 +0,0 @@
-export declare function openApp(): void;

package/dist/slices/remove-field/index.d.ts

@@ -1,8 +0,0 @@
-import type { EventModel } from '../../types.js';
-export declare function removeField(model: EventModel, filePath: string, options: {
-    command?: string;
-    event?: string;
-    readModel?: string;
-    screen?: string;
-    processor?: string;
-}, fieldName: string): void;