eventmodeler 0.4.7 → 0.6.0

package/dist/slices/show-completeness/index.js

@@ -1,731 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-const INCOMING_FLOW_TYPES = {
-    command: ['ScreenToCommand', 'ProcessorToCommand'],
-    event: ['CommandToEvent'],
-    readModel: ['EventToReadModel'],
-    screen: ['ReadModelToScreen'],
-    processor: ['ReadModelToProcessor'],
-};
-function findElementByName(model, name) {
-    // Check for UUID lookup (id:prefix or full UUID format)
-    if (name.startsWith('id:')) {
-        const idSearch = name.slice(3).toLowerCase();
-        // Search all element types by ID
-        for (const cmd of model.commands.values()) {
-            if (cmd.id.toLowerCase().startsWith(idSearch)) {
-                return { element: { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' }, ambiguous: [] };
-            }
-        }
-        for (const evt of model.events.values()) {
-            if (evt.id.toLowerCase().startsWith(idSearch)) {
-                return { element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, ambiguous: [] };
-            }
-        }
-        for (const rm of model.readModels.values()) {
-            if (rm.id.toLowerCase().startsWith(idSearch)) {
-                return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, ambiguous: [] };
-            }
-        }
-        for (const scr of model.screens.values()) {
-            if (scr.id.toLowerCase().startsWith(idSearch)) {
-                return { element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, ambiguous: [] };
-            }
-        }
-        for (const proc of model.processors.values()) {
-            if (proc.id.toLowerCase().startsWith(idSearch)) {
-                return { element: { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' }, ambiguous: [] };
-            }
-        }
-        return { element: null, ambiguous: [] };
-    }
-    // Check if it's a full UUID
-    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(name)) {
-        const cmd = model.commands.get(name);
-        if (cmd)
-            return { element: { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' }, ambiguous: [] };
-        const evt = model.events.get(name);
-        if (evt)
-            return { element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, ambiguous: [] };
-        const rm = model.readModels.get(name);
-        if (rm)
-            return { element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, ambiguous: [] };
-        const scr = model.screens.get(name);
-        if (scr)
-            return { element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, ambiguous: [] };
-        const proc = model.processors.get(name);
-        if (proc)
-            return { element: { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' }, ambiguous: [] };
-        return { element: null, ambiguous: [] };
-    }
-    // Case-insensitive exact name match across all types
-    // Skip linked copies for events, readModels, and screens - they share identity with canonical original
-    const nameLower = name.toLowerCase();
-    const matches = [];
-    for (const cmd of model.commands.values()) {
-        if (cmd.name.toLowerCase() === nameLower) {
-            matches.push({ element: { id: cmd.id, name: cmd.name, fields: cmd.fields, type: 'command' }, type: 'command' });
-        }
-    }
-    for (const evt of model.events.values()) {
-        if (!evt.originalNodeId && evt.name.toLowerCase() === nameLower) {
-            matches.push({ element: { id: evt.id, name: evt.name, fields: evt.fields, type: 'event' }, type: 'event' });
-        }
-    }
-    for (const rm of model.readModels.values()) {
-        if (!rm.originalNodeId && rm.name.toLowerCase() === nameLower) {
-            matches.push({ element: { id: rm.id, name: rm.name, fields: rm.fields, type: 'readModel', canonicalId: rm.canonicalId }, type: 'readModel' });
-        }
-    }
-    for (const scr of model.screens.values()) {
-        if (!scr.originalNodeId && scr.name.toLowerCase() === nameLower) {
-            matches.push({ element: { id: scr.id, name: scr.name, fields: scr.fields, type: 'screen' }, type: 'screen' });
-        }
-    }
-    for (const proc of model.processors.values()) {
-        if (proc.name.toLowerCase() === nameLower) {
-            matches.push({ element: { id: proc.id, name: proc.name, fields: proc.fields, type: 'processor' }, type: 'processor' });
-        }
-    }
-    if (matches.length === 1) {
-        return { element: matches[0].element, ambiguous: [] };
-    }
-    if (matches.length > 1) {
-        return { element: null, ambiguous: matches };
-    }
-    return { element: null, ambiguous: [] };
-}
-function getSourceFields(model, sourceId) {
-    const cmd = model.commands.get(sourceId);
-    if (cmd)
-        return cmd.fields;
-    const evt = model.events.get(sourceId);
-    if (evt)
-        return evt.fields;
-    const rm = model.readModels.get(sourceId);
-    if (rm)
-        return rm.fields;
-    const scr = model.screens.get(sourceId);
-    if (scr)
-        return scr.fields;
-    const proc = model.processors.get(sourceId);
-    if (proc)
-        return proc.fields;
-    return [];
-}
-/**
- * Flattens nested Custom fields into a flat list with dot-notation paths.
- * When skipCustomParents is true, Custom fields with subfields are excluded.
- */
-function flattenFields(fields, prefix = '', skipCustomParents = false) {
-    const result = [];
-    for (const field of fields) {
-        const path = prefix ? `${prefix}.${field.name}` : field.name;
-        const isCustomParent = field.fieldType === 'Custom' &&
-            field.subfields &&
-            field.subfields.length > 0;
-        if (!skipCustomParents || !isCustomParent) {
-            result.push({ id: field.id, path, field });
-        }
-        if (field.fieldType === 'Custom' && field.subfields) {
-            result.push(...flattenFields(field.subfields, path, skipCustomParents));
-        }
-    }
-    return result;
-}
-/**
- * Calculates completeness for a read model using the union approach.
- * A field is satisfied if ANY incoming event provides it.
- * For linked copies, considers flows into ALL nodes in the canonical group.
- */
-function calculateReadModelUnionCompleteness(model, readModelId, readModelFields, canonicalId) {
-    // Find all node IDs in the canonical group (original + all copies)
-    let targetNodeIds;
-    if (canonicalId) {
-        targetNodeIds = [...model.readModels.values()]
-            .filter(rm => rm.canonicalId === canonicalId)
-            .map(rm => rm.id);
-    }
-    else {
-        targetNodeIds = [readModelId];
-    }
-    // Find all incoming EventToReadModel flows to ANY node in the group
-    const incomingFlows = [...model.flows.values()].filter(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
-    // Collect all source fields from all incoming events (union)
-    const allSourceFields = [];
-    const allManualMappings = [];
-    const sourceEventNames = [];
-    for (const flow of incomingFlows) {
-        const sourceFields = getSourceFields(model, flow.sourceId);
-        allSourceFields.push(...flattenFields(sourceFields));
-        if (flow.fieldMappings) {
-            allManualMappings.push(...flow.fieldMappings);
-        }
-        // Get event name for reporting
-        const event = model.events.get(flow.sourceId);
-        if (event && !sourceEventNames.includes(event.name)) {
-            sourceEventNames.push(event.name);
-        }
-    }
-    // Check each target field against the union of all sources
-    // Skip custom parents - only check leaf fields
-    const flatTarget = flattenFields(readModelFields, '', true);
-    const untraceableFields = [];
-    const optionalMissingFields = [];
-    const fieldStatuses = [];
-    for (const { id, path, field } of flatTarget) {
-        // 1. Generated fields don't need a source
-        if (field.isGenerated) {
-            fieldStatuses.push({ fieldId: id, fieldName: path, status: 'generated' });
-            continue;
-        }
-        // 2. Check if there's a manual mapping from any flow
-        const manualMapping = allManualMappings.find(m => m.targetFieldId === id);
-        if (manualMapping) {
-            const sourceField = allSourceFields.find(sf => sf.id === manualMapping.sourceFieldId);
-            fieldStatuses.push({
-                fieldId: id,
-                fieldName: path,
-                status: 'satisfied',
-                sourceFieldId: manualMapping.sourceFieldId,
-                sourceFieldName: sourceField?.path,
-            });
-            continue;
-        }
-        // 3. Check auto-mapping by path match from any source
-        const autoMatch = allSourceFields.find(sf => sf.path === path);
-        if (autoMatch) {
-            fieldStatuses.push({
-                fieldId: id,
-                fieldName: path,
-                status: 'satisfied',
-                sourceFieldId: autoMatch.id,
-                sourceFieldName: autoMatch.path,
-            });
-            continue;
-        }
-        // 4. Optional fields missing is a warning, not an error
-        if (field.isOptional) {
-            optionalMissingFields.push(path);
-            fieldStatuses.push({ fieldId: id, fieldName: path, status: 'optional-missing' });
-            continue;
-        }
-        // Field is untraceable (required but no source)
-        untraceableFields.push(path);
-        fieldStatuses.push({ fieldId: id, fieldName: path, status: 'unsatisfied' });
-    }
-    return {
-        isComplete: untraceableFields.length === 0,
-        hasWarnings: optionalMissingFields.length > 0,
-        untraceableFields,
-        optionalMissingFields,
-        sourceEvents: sourceEventNames,
-        fieldStatuses,
-    };
-}
-function calculateFlowCompleteness(model, flow, targetFields, sourceFields) {
-    const flatSource = flattenFields(sourceFields);
-    // Skip custom parents for target fields - only check leaf fields
-    const flatTarget = flattenFields(targetFields, '', true);
-    const manualMappings = flow.fieldMappings ?? [];
-    // Get source entity name
-    let sourceName = 'Unknown';
-    let sourceType = 'unknown';
-    const event = model.events.get(flow.sourceId);
-    const readModel = model.readModels.get(flow.sourceId);
-    const command = model.commands.get(flow.sourceId);
-    const screen = model.screens.get(flow.sourceId);
-    const processor = model.processors.get(flow.sourceId);
-    if (event) {
-        sourceName = event.name;
-        sourceType = 'event';
-    }
-    else if (readModel) {
-        sourceName = readModel.name;
-        sourceType = 'read-model';
-    }
-    else if (command) {
-        sourceName = command.name;
-        sourceType = 'command';
-    }
-    else if (screen) {
-        sourceName = screen.name;
-        sourceType = 'screen';
-    }
-    else if (processor) {
-        sourceName = processor.name;
-        sourceType = 'processor';
-    }
-    const fieldStatuses = flatTarget.map(({ id, path, field }) => {
-        // 1. Check if generated
-        if (field.isGenerated) {
-            return { fieldId: id, fieldName: path, status: 'generated' };
-        }
-        // 2. Check if user input
-        if (field.isUserInput) {
-            return { fieldId: id, fieldName: path, status: 'user-input' };
-        }
-        // 3. Check manual mapping
-        const manualMapping = manualMappings.find(m => m.targetFieldId === id);
-        if (manualMapping) {
-            const sourceField = flatSource.find(sf => sf.id === manualMapping.sourceFieldId);
-            return {
-                fieldId: id,
-                fieldName: path,
-                status: 'satisfied',
-                sourceFieldId: manualMapping.sourceFieldId,
-                sourceFieldName: sourceField?.path,
-            };
-        }
-        // 4. Check auto-mapping by path
-        const autoMatch = flatSource.find(sf => sf.path === path);
-        if (autoMatch) {
-            return {
-                fieldId: id,
-                fieldName: path,
-                status: 'satisfied',
-                sourceFieldId: autoMatch.id,
-                sourceFieldName: autoMatch.path,
-            };
-        }
-        // 5. Not satisfied - check if optional
-        if (field.isOptional) {
-            return { fieldId: id, fieldName: path, status: 'optional-missing' };
-        }
-        // 6. Unsatisfied required field
-        return { fieldId: id, fieldName: path, status: 'unsatisfied' };
-    });
-    const hasUnsatisfied = fieldStatuses.some(s => s.status === 'unsatisfied');
-    const hasOptionalMissing = fieldStatuses.some(s => s.status === 'optional-missing');
-    return {
-        flowId: flow.id,
-        sourceName,
-        sourceType,
-        isComplete: !hasUnsatisfied,
-        hasWarnings: hasOptionalMissing,
-        targetFields: fieldStatuses,
-        sourceFields: flatSource.map(sf => ({
-            id: sf.id,
-            name: sf.path,
-            type: sf.field.fieldType,
-            isList: sf.field.isList,
-        })),
-    };
-}
-export function showCompleteness(model, elementName, format) {
-    // Find the element by name (searches all element types)
-    const { element, ambiguous } = findElementByName(model, elementName);
-    if (ambiguous.length > 0) {
-        console.error(`Error: Multiple elements found with name "${elementName}"`);
-        console.error('Please specify using the element ID:');
-        for (const match of ambiguous) {
-            console.error(`  - "${match.element.name}" (${match.type}) (id: ${match.element.id})`);
-        }
-        console.error('');
-        console.error(`Usage: eventmodeler show completeness "id:${ambiguous[0].element.id.slice(0, 8)}"`);
-        process.exit(1);
-    }
-    if (!element) {
-        console.error(`Error: Element not found: "${elementName}"`);
-        // List all available elements with their IDs
-        const allElements = [];
-        for (const cmd of model.commands.values()) {
-            allElements.push({ name: cmd.name, type: 'command', id: cmd.id });
-        }
-        for (const evt of model.events.values()) {
-            allElements.push({ name: evt.name, type: 'event', id: evt.id });
-        }
-        for (const rm of model.readModels.values()) {
-            allElements.push({ name: rm.name, type: 'read model', id: rm.id });
-        }
-        for (const scr of model.screens.values()) {
-            allElements.push({ name: scr.name, type: 'screen', id: scr.id });
-        }
-        for (const proc of model.processors.values()) {
-            allElements.push({ name: proc.name, type: 'processor', id: proc.id });
-        }
-        if (allElements.length > 0) {
-            console.error('Available elements:');
-            for (const el of allElements) {
-                console.error(`  - "${el.name}" (${el.type}) (id: ${el.id.slice(0, 8)})`);
-            }
-        }
-        else {
-            console.error('No elements exist in the model.');
-        }
-        process.exit(1);
-    }
-    const elementTypeLabel = element.type === 'readModel' ? 'read-model' : element.type;
-    // For read models, use union completeness (all incoming events combined)
-    if (element.type === 'readModel') {
-        const unionResult = calculateReadModelUnionCompleteness(model, element.id, element.fields, element.canonicalId);
-        // Check if there are any incoming flows at all
-        let targetNodeIds;
-        if (element.canonicalId) {
-            targetNodeIds = [...model.readModels.values()]
-                .filter(rm => rm.canonicalId === element.canonicalId)
-                .map(rm => rm.id);
-        }
-        else {
-            targetNodeIds = [element.id];
-        }
-        const hasIncomingFlows = [...model.flows.values()].some(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
-        if (!hasIncomingFlows) {
-            if (format === 'json') {
-                outputJson({
-                    elementType: elementTypeLabel,
-                    name: element.name,
-                    message: `No flows into this ${elementTypeLabel}`
-                });
-            }
-            else {
-                console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}">`);
-                console.log(`  <no-flows>No flows into this ${elementTypeLabel}</no-flows>`);
-                console.log('</completeness>');
-            }
-            return;
-        }
-        const overallStatus = unionResult.isComplete ? 'complete' : 'incomplete';
-        const flatTargetFields = flattenFields(element.fields);
-        if (format === 'json') {
-            outputJson({
-                elementType: elementTypeLabel,
-                name: element.name,
-                status: overallStatus,
-                ...(unionResult.hasWarnings ? { hasWarnings: true } : {}),
-                sourceEvents: unionResult.sourceEvents,
-                ...(unionResult.untraceableFields.length > 0 ? { untraceableFields: unionResult.untraceableFields } : {}),
-                ...(unionResult.optionalMissingFields.length > 0 ? { optionalMissingFields: unionResult.optionalMissingFields } : {}),
-                fieldStatuses: unionResult.fieldStatuses.map(f => ({
-                    name: f.fieldName,
-                    status: f.status,
-                    ...(f.sourceFieldName ? { source: f.sourceFieldName } : {})
-                })),
-                elementFields: flatTargetFields.map(({ id, path, field }) => ({
-                    id,
-                    name: path,
-                    type: field.fieldType,
-                    ...(field.isList ? { isList: true } : {}),
-                    ...(field.isOptional ? { isOptional: true } : {}),
-                    ...(field.isGenerated ? { isGenerated: true } : {})
-                }))
-            });
-            return;
-        }
-        // XML output for read models
-        console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}" status="${overallStatus}"${unionResult.hasWarnings ? ' hasWarnings="true"' : ''}>`);
-        console.log('  <source-events>');
-        for (const eventName of unionResult.sourceEvents) {
-            console.log(`    <event name="${escapeXml(eventName)}"/>`);
-        }
-        console.log('  </source-events>');
-        if (unionResult.untraceableFields.length > 0) {
-            console.log('  <untraceable-fields>');
-            for (const fieldName of unionResult.untraceableFields) {
-                console.log(`    <field name="${escapeXml(fieldName)}"/>`);
-            }
-            console.log('  </untraceable-fields>');
-        }
-        if (unionResult.optionalMissingFields.length > 0) {
-            console.log('  <optional-missing-fields>');
-            for (const fieldName of unionResult.optionalMissingFields) {
-                console.log(`    <field name="${escapeXml(fieldName)}"/>`);
-            }
-            console.log('  </optional-missing-fields>');
-        }
-        console.log('  <field-statuses>');
-        for (const field of unionResult.fieldStatuses) {
-            if (field.sourceFieldName) {
-                console.log(`    <field name="${escapeXml(field.fieldName)}" status="${field.status}" source="${escapeXml(field.sourceFieldName)}"/>`);
-            }
-            else {
-                console.log(`    <field name="${escapeXml(field.fieldName)}" status="${field.status}"/>`);
-            }
-        }
-        console.log('  </field-statuses>');
-        console.log(`  <${elementTypeLabel}-fields>`);
-        for (const { id, path, field } of flatTargetFields) {
-            const attrs = [`id="${id}"`, `name="${escapeXml(path)}"`, `type="${field.fieldType}"`];
-            if (field.isList)
-                attrs.push('isList="true"');
-            if (field.isOptional)
-                attrs.push('isOptional="true"');
-            if (field.isGenerated)
-                attrs.push('isGenerated="true"');
-            console.log(`    <field ${attrs.join(' ')}/>`);
-        }
-        console.log(`  </${elementTypeLabel}-fields>`);
-        console.log('</completeness>');
-        return;
-    }
-    // For non-read-model elements, use per-flow completeness
-    const validFlowTypes = INCOMING_FLOW_TYPES[element.type];
-    const incomingFlows = [...model.flows.values()].filter(f => f.targetId === element.id && validFlowTypes.includes(f.flowType));
-    if (incomingFlows.length === 0) {
-        if (format === 'json') {
-            outputJson({
-                elementType: elementTypeLabel,
-                name: element.name,
-                message: `No flows into this ${elementTypeLabel}`
-            });
-        }
-        else {
-            console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}">`);
-            console.log(`  <no-flows>No flows into this ${elementTypeLabel}</no-flows>`);
-            console.log('</completeness>');
-        }
-        return;
-    }
-    // Calculate completeness for each flow
-    const completenessResults = [];
-    for (const flow of incomingFlows) {
-        const sourceFields = getSourceFields(model, flow.sourceId);
-        if (sourceFields.length === 0 && element.fields.length > 0) {
-            // Source has no fields but target expects some - still calculate
-        }
-        const result = calculateFlowCompleteness(model, flow, element.fields, sourceFields);
-        completenessResults.push(result);
-    }
-    const overallComplete = completenessResults.every(r => r.isComplete);
-    const overallStatus = overallComplete ? 'complete' : 'incomplete';
-    if (format === 'json') {
-        const flatTargetFields = flattenFields(element.fields);
-        outputJson({
-            elementType: elementTypeLabel,
-            name: element.name,
-            status: overallStatus,
-            flows: completenessResults.map(result => ({
-                flowId: result.flowId,
-                from: result.sourceName,
-                sourceType: result.sourceType,
-                status: result.isComplete ? 'complete' : 'incomplete',
-                ...(result.hasWarnings ? { hasWarnings: true } : {}),
-                targetFields: result.targetFields.map(f => ({
-                    name: f.fieldName,
-                    status: f.status,
-                    ...(f.sourceFieldName ? { source: f.sourceFieldName } : {})
-                })),
-                availableSourceFields: result.sourceFields.map(sf => ({
-                    id: sf.id,
-                    name: sf.name,
-                    type: sf.type,
-                    ...(sf.isList ? { isList: true } : {})
-                }))
-            })),
-            elementFields: flatTargetFields.map(({ id, path, field }) => ({
-                id,
-                name: path,
-                type: field.fieldType,
-                ...(field.isList ? { isList: true } : {}),
-                ...(field.isOptional ? { isOptional: true } : {}),
-                ...(field.isGenerated ? { isGenerated: true } : {})
-            }))
-        });
-        return;
-    }
-    // Output XML
-    console.log(`<completeness ${elementTypeLabel}="${escapeXml(element.name)}" status="${overallStatus}">`);
-    for (const result of completenessResults) {
-        const flowStatus = result.isComplete ? 'complete' : 'incomplete';
-        const warningAttr = result.hasWarnings ? ' hasWarnings="true"' : '';
-        console.log(`  <flow id="${result.flowId}" from="${escapeXml(result.sourceName)}" type="${result.sourceType}" status="${flowStatus}"${warningAttr}>`);
-        // Target fields
-        console.log('    <target-fields>');
-        for (const field of result.targetFields) {
-            if (field.sourceFieldName) {
-                console.log(`      <field name="${escapeXml(field.fieldName)}" status="${field.status}" source="${escapeXml(field.sourceFieldName)}"/>`);
-            }
-            else {
-                console.log(`      <field name="${escapeXml(field.fieldName)}" status="${field.status}"/>`);
-            }
-        }
-        console.log('    </target-fields>');
-        // Available source fields (for AI to see what's available)
-        console.log('    <available-source-fields>');
-        for (const sf of result.sourceFields) {
-            const listAttr = sf.isList ? ' isList="true"' : '';
-            console.log(`      <field id="${sf.id}" name="${escapeXml(sf.name)}" type="${sf.type}"${listAttr}/>`);
-        }
-        console.log('    </available-source-fields>');
-        console.log('  </flow>');
-    }
-    // Also show the element's fields with their IDs (needed for mapping)
-    console.log(`  <${elementTypeLabel}-fields>`);
-    const flatTargetFields = flattenFields(element.fields);
-    for (const { id, path, field } of flatTargetFields) {
-        const attrs = [`id="${id}"`, `name="${escapeXml(path)}"`, `type="${field.fieldType}"`];
-        if (field.isList)
-            attrs.push('isList="true"');
-        if (field.isOptional)
-            attrs.push('isOptional="true"');
-        if (field.isGenerated)
-            attrs.push('isGenerated="true"');
-        console.log(`    <field ${attrs.join(' ')}/>`);
-    }
-    console.log(`  </${elementTypeLabel}-fields>`);
-    console.log('</completeness>');
-}
-export function showModelCompleteness(model, format) {
-    const allFlows = [...model.flows.values()];
-    const incompleteFlows = [];
-    let completeCount = 0;
-    let totalCount = 0;
-    // For read models, we use union completeness - track which canonical groups we've processed
-    const processedReadModelGroups = new Set();
-    const incompleteReadModels = [];
-    let readModelCompleteCount = 0;
-    let readModelTotalCount = 0;
-    for (const flow of allFlows) {
-        // Skip EventToReadModel flows - we handle read models separately with union logic
-        if (flow.flowType === 'EventToReadModel') {
-            continue;
-        }
-        // Get target element info
-        let targetName = 'Unknown';
-        let targetType = 'unknown';
-        let targetFields = [];
-        const targetCmd = model.commands.get(flow.targetId);
-        const targetEvt = model.events.get(flow.targetId);
-        const targetScr = model.screens.get(flow.targetId);
-        const targetProc = model.processors.get(flow.targetId);
-        if (targetCmd) {
-            targetName = targetCmd.name;
-            targetType = 'command';
-            targetFields = targetCmd.fields;
-        }
-        else if (targetEvt) {
-            targetName = targetEvt.name;
-            targetType = 'event';
-            targetFields = targetEvt.fields;
-        }
-        else if (targetScr) {
-            targetName = targetScr.name;
-            targetType = 'screen';
-            targetFields = targetScr.fields;
-        }
-        else if (targetProc) {
-            targetName = targetProc.name;
-            targetType = 'processor';
-            targetFields = targetProc.fields;
-        }
-        // Get source fields
-        const sourceFields = getSourceFields(model, flow.sourceId);
-        // Calculate completeness
-        const result = calculateFlowCompleteness(model, flow, targetFields, sourceFields);
-        totalCount++;
-        if (result.isComplete) {
-            completeCount++;
-        }
-        else {
-            const unsatisfiedFields = result.targetFields
-                .filter(f => f.status === 'unsatisfied')
-                .map(f => f.fieldName);
-            incompleteFlows.push({
-                flow,
-                sourceName: result.sourceName,
-                targetName,
-                targetType,
-                unsatisfiedFields,
-            });
-        }
-    }
-    // Process read models with union completeness
-    // Group read models by canonicalId (or use id if no canonicalId)
-    for (const rm of model.readModels.values()) {
-        const groupKey = rm.canonicalId ?? rm.id;
-        // Skip if we've already processed this canonical group
-        if (processedReadModelGroups.has(groupKey)) {
-            continue;
-        }
-        processedReadModelGroups.add(groupKey);
-        // Check if this read model has any incoming EventToReadModel flows
-        let targetNodeIds;
-        if (rm.canonicalId) {
-            targetNodeIds = [...model.readModels.values()]
-                .filter(r => r.canonicalId === rm.canonicalId)
-                .map(r => r.id);
-        }
-        else {
-            targetNodeIds = [rm.id];
-        }
-        const hasIncomingFlows = allFlows.some(f => targetNodeIds.includes(f.targetId) && f.flowType === 'EventToReadModel');
-        if (!hasIncomingFlows) {
-            // No incoming flows - skip this read model
-            continue;
-        }
-        readModelTotalCount++;
-        const unionResult = calculateReadModelUnionCompleteness(model, rm.id, rm.fields, rm.canonicalId);
-        if (unionResult.isComplete) {
-            readModelCompleteCount++;
-        }
-        else {
-            incompleteReadModels.push({
-                name: rm.name,
-                untraceableFields: unionResult.untraceableFields,
-                sourceEvents: unionResult.sourceEvents,
-            });
-        }
-    }
-    const incompleteCount = totalCount - completeCount;
-    const readModelIncompleteCount = readModelTotalCount - readModelCompleteCount;
-    if (format === 'json') {
-        outputJson({
-            summary: {
-                complete: completeCount + readModelCompleteCount,
-                incomplete: incompleteCount + readModelIncompleteCount,
-                total: totalCount + readModelTotalCount
-            },
-            incompleteFlows: incompleteFlows.map(item => ({
-                from: item.sourceName,
-                to: item.targetName,
-                targetType: item.targetType,
-                flowType: item.flow.flowType,
-                unsatisfiedFields: item.unsatisfiedFields
-            })),
-            ...(incompleteReadModels.length > 0 ? {
-                incompleteReadModels: incompleteReadModels.map(item => ({
-                    name: item.name,
-                    untraceableFields: item.untraceableFields,
-                    sourceEvents: item.sourceEvents
-                }))
-            } : {})
-        });
-        return;
-    }
-    console.log('<model-completeness>');
-    console.log(`  <summary complete="${completeCount + readModelCompleteCount}" incomplete="${incompleteCount + readModelIncompleteCount}" total="${totalCount + readModelTotalCount}"/>`);
-    if (incompleteFlows.length > 0) {
-        console.log('  <incomplete-flows>');
-        for (const item of incompleteFlows) {
-            console.log(`    <flow from="${escapeXml(item.sourceName)}" to="${escapeXml(item.targetName)}" target-type="${item.targetType}" flow-type="${item.flow.flowType}">`);
-            if (item.unsatisfiedFields.length > 0) {
-                console.log('      <unsatisfied-fields>');
-                for (const fieldName of item.unsatisfiedFields) {
-                    console.log(`        <field name="${escapeXml(fieldName)}"/>`);
-                }
-                console.log('      </unsatisfied-fields>');
-            }
-            console.log('    </flow>');
-        }
-        console.log('  </incomplete-flows>');
-    }
-    if (incompleteReadModels.length > 0) {
-        console.log('  <incomplete-read-models>');
-        for (const item of incompleteReadModels) {
-            console.log(`    <read-model name="${escapeXml(item.name)}">`);
-            console.log('      <untraceable-fields>');
-            for (const fieldName of item.untraceableFields) {
-                console.log(`        <field name="${escapeXml(fieldName)}"/>`);
-            }
-            console.log('      </untraceable-fields>');
-            console.log('      <source-events>');
-            for (const eventName of item.sourceEvents) {
-                console.log(`        <event name="${escapeXml(eventName)}"/>`);
-            }
-            console.log('      </source-events>');
-            console.log('    </read-model>');
-        }
-        console.log('  </incomplete-read-models>');
-    }
-    console.log('</model-completeness>');
-}