@synergenius/flow-weaver 0.2.0

package/dist/diff/WorkflowDiffer.js

@@ -0,0 +1,429 @@
+/**
+ * WorkflowDiffer - Semantic diff for workflows.
+ * Compares semantic fields, ignores visual/metadata fields.
+ */
+/**
+ * Create connection key for comparison (ignores metadata/sourceLocation)
+ */
+function connectionKey(conn) {
+    return `${conn.from.node}:${conn.from.port}:${conn.from.scope ?? ''}->${conn.to.node}:${conn.to.port}:${conn.to.scope ?? ''}`;
+}
+/**
+ * Deep equality for port definitions (semantic fields only)
+ */
+function portDefinitionEquals(a, b) {
+    return (a.dataType === b.dataType &&
+        a.tsType === b.tsType &&
+        a.optional === b.optional &&
+        JSON.stringify(a.default) === JSON.stringify(b.default) &&
+        a.expression === b.expression &&
+        a.scope === b.scope &&
+        a.mergeStrategy === b.mergeStrategy);
+}
+/**
+ * Compare port maps and return changes
+ */
+function comparePortMaps(beforePorts, afterPorts, direction) {
+    const changes = [];
+    const beforeKeys = new Set(Object.keys(beforePorts));
+    const afterKeys = new Set(Object.keys(afterPorts));
+    // Added ports
+    for (const key of afterKeys) {
+        if (!beforeKeys.has(key)) {
+            changes.push({
+                portName: key,
+                direction,
+                type: 'ADDED',
+                after: afterPorts[key],
+            });
+        }
+    }
+    // Removed ports
+    for (const key of beforeKeys) {
+        if (!afterKeys.has(key)) {
+            changes.push({
+                portName: key,
+                direction,
+                type: 'REMOVED',
+                before: beforePorts[key],
+            });
+        }
+    }
+    // Modified ports
+    for (const key of beforeKeys) {
+        if (afterKeys.has(key) && !portDefinitionEquals(beforePorts[key], afterPorts[key])) {
+            changes.push({
+                portName: key,
+                direction,
+                type: 'MODIFIED',
+                before: beforePorts[key],
+                after: afterPorts[key],
+            });
+        }
+    }
+    return changes;
+}
+/**
+ * Compare node types semantically
+ */
+function compareNodeType(before, after) {
+    const changes = {};
+    let hasChanges = false;
+    // Compare functionName
+    if (before.functionName !== after.functionName) {
+        changes.functionName = { type: 'MODIFIED', before: before.functionName, after: after.functionName };
+        hasChanges = true;
+    }
+    // Compare executeWhen
+    if (before.executeWhen !== after.executeWhen) {
+        changes.executeWhen = { type: 'MODIFIED', before: before.executeWhen, after: after.executeWhen };
+        hasChanges = true;
+    }
+    // Compare branchingStrategy
+    if (before.branchingStrategy !== after.branchingStrategy) {
+        changes.branchingStrategy = { type: 'MODIFIED', before: before.branchingStrategy, after: after.branchingStrategy };
+        hasChanges = true;
+    }
+    // Compare isAsync
+    if (before.isAsync !== after.isAsync) {
+        changes.isAsync = { type: 'MODIFIED', before: before.isAsync, after: after.isAsync };
+        hasChanges = true;
+    }
+    // Compare scope
+    if (before.scope !== after.scope) {
+        changes.scope = { type: 'MODIFIED', before: before.scope, after: after.scope };
+        hasChanges = true;
+    }
+    // Compare variant
+    if (before.variant !== after.variant) {
+        changes.variant = { type: 'MODIFIED', before: before.variant, after: after.variant };
+        hasChanges = true;
+    }
+    // Compare inputs
+    const inputChanges = comparePortMaps(before.inputs, after.inputs, 'INPUT');
+    if (inputChanges.length > 0) {
+        changes.inputs = inputChanges;
+        hasChanges = true;
+    }
+    // Compare outputs
+    const outputChanges = comparePortMaps(before.outputs, after.outputs, 'OUTPUT');
+    if (outputChanges.length > 0) {
+        changes.outputs = outputChanges;
+        hasChanges = true;
+    }
+    if (!hasChanges)
+        return null;
+    return {
+        name: before.name,
+        changeType: 'MODIFIED',
+        changes,
+    };
+}
+/**
+ * Compare instance UI data
+ */
+function compareInstanceUI(beforeUI, afterUI) {
+    if (!beforeUI && !afterUI)
+        return null;
+    const uiChanges = {};
+    let hasUIChanges = false;
+    const beforeLabel = beforeUI?.label ?? '';
+    const afterLabel = afterUI?.label ?? '';
+    if (beforeLabel !== afterLabel) {
+        uiChanges.label = { type: 'MODIFIED', before: beforeLabel, after: afterLabel };
+        hasUIChanges = true;
+    }
+    const beforeX = beforeUI?.x ?? 0;
+    const beforeY = beforeUI?.y ?? 0;
+    const afterX = afterUI?.x ?? 0;
+    const afterY = afterUI?.y ?? 0;
+    if (beforeX !== afterX || beforeY !== afterY) {
+        uiChanges.position = {
+            type: 'MODIFIED',
+            before: { x: beforeX, y: beforeY },
+            after: { x: afterX, y: afterY },
+        };
+        hasUIChanges = true;
+    }
+    const beforeWidth = beforeUI?.width ?? 0;
+    const beforeHeight = beforeUI?.height ?? 0;
+    const afterWidth = afterUI?.width ?? 0;
+    const afterHeight = afterUI?.height ?? 0;
+    if (beforeWidth !== afterWidth || beforeHeight !== afterHeight) {
+        uiChanges.size = {
+            type: 'MODIFIED',
+            before: { width: beforeWidth, height: beforeHeight },
+            after: { width: afterWidth, height: afterHeight },
+        };
+        hasUIChanges = true;
+    }
+    const beforeMinimized = beforeUI?.minimized ?? false;
+    const afterMinimized = afterUI?.minimized ?? false;
+    if (beforeMinimized !== afterMinimized) {
+        uiChanges.minimized = { type: 'MODIFIED', before: beforeMinimized, after: afterMinimized };
+        hasUIChanges = true;
+    }
+    return hasUIChanges ? uiChanges : null;
+}
+/**
+ * Compare instances semantically
+ */
+function compareInstance(before, after, beforeUI, afterUI) {
+    const changes = {};
+    let hasChanges = false;
+    // Compare nodeType
+    if (before.nodeType !== after.nodeType) {
+        changes.nodeType = { type: 'MODIFIED', before: before.nodeType, after: after.nodeType };
+        hasChanges = true;
+    }
+    // Compare parent
+    const beforeParent = before.parent ?? null;
+    const afterParent = after.parent ?? null;
+    if (JSON.stringify(beforeParent) !== JSON.stringify(afterParent)) {
+        changes.parent = { type: 'MODIFIED', before: beforeParent, after: afterParent };
+        hasChanges = true;
+    }
+    // Compare config (only semantic fields: pullExecution, portConfigs)
+    const beforeConfig = before.config;
+    const afterConfig = after.config;
+    const configChanges = {};
+    let hasConfigChanges = false;
+    // pullExecution
+    const beforePullExec = beforeConfig?.pullExecution;
+    const afterPullExec = afterConfig?.pullExecution;
+    if (JSON.stringify(beforePullExec) !== JSON.stringify(afterPullExec)) {
+        configChanges.pullExecution = { type: 'MODIFIED', before: beforePullExec, after: afterPullExec };
+        hasConfigChanges = true;
+    }
+    // portConfigs
+    const beforePortConfigs = beforeConfig?.portConfigs;
+    const afterPortConfigs = afterConfig?.portConfigs;
+    if (JSON.stringify(beforePortConfigs) !== JSON.stringify(afterPortConfigs)) {
+        configChanges.portConfigs = { type: 'MODIFIED', before: beforePortConfigs, after: afterPortConfigs };
+        hasConfigChanges = true;
+    }
+    if (hasConfigChanges) {
+        changes.config = configChanges;
+        hasChanges = true;
+    }
+    // Compare UI data
+    const uiChanges = compareInstanceUI(beforeUI, afterUI);
+    if (uiChanges) {
+        changes.ui = uiChanges;
+        hasChanges = true;
+    }
+    if (!hasChanges)
+        return null;
+    return {
+        id: before.id,
+        changeType: 'MODIFIED',
+        changes,
+    };
+}
+/**
+ * Compare workflow ports (startPorts or exitPorts)
+ */
+function compareWorkflowPorts(beforePorts, afterPorts) {
+    const result = {
+        added: [],
+        removed: [],
+        modified: [],
+    };
+    const beforeKeys = new Set(Object.keys(beforePorts));
+    const afterKeys = new Set(Object.keys(afterPorts));
+    // Added
+    for (const key of afterKeys) {
+        if (!beforeKeys.has(key)) {
+            result.added.push({ name: key, definition: afterPorts[key] });
+        }
+    }
+    // Removed
+    for (const key of beforeKeys) {
+        if (!afterKeys.has(key)) {
+            result.removed.push({ name: key, definition: beforePorts[key] });
+        }
+    }
+    // Modified
+    for (const key of beforeKeys) {
+        if (afterKeys.has(key) && !portDefinitionEquals(beforePorts[key], afterPorts[key])) {
+            result.modified.push({
+                name: key,
+                before: beforePorts[key],
+                after: afterPorts[key],
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Calculate overall impact level
+ */
+function calculateImpact(diff) {
+    // CRITICAL: Removed connections to Exit or from Start
+    const criticalConnections = diff.connections.some(c => c.changeType === 'REMOVED' && (c.from.node === 'Start' || c.to.node === 'Exit'));
+    if (criticalConnections)
+        return 'CRITICAL';
+    // CRITICAL: Removed start/exit ports
+    if (diff.startPorts.removed.length > 0 || diff.exitPorts.removed.length > 0) {
+        return 'CRITICAL';
+    }
+    // BREAKING: Removed node types, instances, or connections
+    if (diff.summary.nodeTypesRemoved > 0 ||
+        diff.summary.instancesRemoved > 0 ||
+        diff.summary.connectionsRemoved > 0) {
+        return 'BREAKING';
+    }
+    // BREAKING: Port dataType changes
+    const hasBreakingPortChanges = diff.nodeTypes.some(nt => {
+        const inputChanges = nt.changes.inputs?.some(p => p.type === 'REMOVED' || (p.type === 'MODIFIED' && p.before?.dataType !== p.after?.dataType));
+        const outputChanges = nt.changes.outputs?.some(p => p.type === 'REMOVED' || (p.type === 'MODIFIED' && p.before?.dataType !== p.after?.dataType));
+        return inputChanges || outputChanges;
+    });
+    if (hasBreakingPortChanges)
+        return 'BREAKING';
+    // MINOR: Added nodes, instances, connections, or ports
+    if (diff.summary.nodeTypesAdded > 0 ||
+        diff.summary.instancesAdded > 0 ||
+        diff.summary.connectionsAdded > 0 ||
+        diff.startPorts.added.length > 0 ||
+        diff.exitPorts.added.length > 0) {
+        return 'MINOR';
+    }
+    // MINOR: Modified nodes or instances
+    if (diff.summary.nodeTypesModified > 0 || diff.summary.instancesModified > 0) {
+        return 'MINOR';
+    }
+    // COSMETIC: No semantic changes
+    return 'COSMETIC';
+}
+export class WorkflowDiffer {
+    /**
+     * Compare two workflows and return semantic diff
+     */
+    static compare(before, after) {
+        const nodeTypes = [];
+        const instances = [];
+        const connections = [];
+        const scopes = [];
+        // Build lookup maps
+        const beforeNodeTypes = new Map(before.nodeTypes.map(nt => [nt.name, nt]));
+        const afterNodeTypes = new Map(after.nodeTypes.map(nt => [nt.name, nt]));
+        const beforeInstances = new Map(before.instances.map(i => [i.id, i]));
+        const afterInstances = new Map(after.instances.map(i => [i.id, i]));
+        const beforeConnections = new Map(before.connections.map(c => [connectionKey(c), c]));
+        const afterConnections = new Map(after.connections.map(c => [connectionKey(c), c]));
+        const beforeScopes = before.scopes ?? {};
+        const afterScopes = after.scopes ?? {};
+        // Build UI lookup maps
+        const beforeUIInstances = new Map((before.ui?.instances ?? []).map(ui => [ui.name, ui]));
+        const afterUIInstances = new Map((after.ui?.instances ?? []).map(ui => [ui.name, ui]));
+        // Compare node types
+        for (const [name, nt] of afterNodeTypes) {
+            if (!beforeNodeTypes.has(name)) {
+                nodeTypes.push({ name, changeType: 'ADDED', changes: {} });
+            }
+            else {
+                const diff = compareNodeType(beforeNodeTypes.get(name), nt);
+                if (diff)
+                    nodeTypes.push(diff);
+            }
+        }
+        for (const [name] of beforeNodeTypes) {
+            if (!afterNodeTypes.has(name)) {
+                nodeTypes.push({ name, changeType: 'REMOVED', changes: {} });
+            }
+        }
+        // Compare instances
+        for (const [id, inst] of afterInstances) {
+            if (!beforeInstances.has(id)) {
+                instances.push({ id, changeType: 'ADDED', changes: {} });
+            }
+            else {
+                const diff = compareInstance(beforeInstances.get(id), inst, beforeUIInstances.get(id), afterUIInstances.get(id));
+                if (diff)
+                    instances.push(diff);
+            }
+        }
+        for (const [id] of beforeInstances) {
+            if (!afterInstances.has(id)) {
+                instances.push({ id, changeType: 'REMOVED', changes: {} });
+            }
+        }
+        // Compare connections
+        for (const [key, conn] of afterConnections) {
+            if (!beforeConnections.has(key)) {
+                connections.push({
+                    changeType: 'ADDED',
+                    from: { node: conn.from.node, port: conn.from.port, scope: conn.from.scope },
+                    to: { node: conn.to.node, port: conn.to.port, scope: conn.to.scope },
+                });
+            }
+        }
+        for (const [key, conn] of beforeConnections) {
+            if (!afterConnections.has(key)) {
+                connections.push({
+                    changeType: 'REMOVED',
+                    from: { node: conn.from.node, port: conn.from.port, scope: conn.from.scope },
+                    to: { node: conn.to.node, port: conn.to.port, scope: conn.to.scope },
+                });
+            }
+        }
+        // Compare scopes
+        const allScopeNames = new Set([...Object.keys(beforeScopes), ...Object.keys(afterScopes)]);
+        for (const name of allScopeNames) {
+            const beforeMembers = beforeScopes[name];
+            const afterMembers = afterScopes[name];
+            if (!beforeMembers) {
+                scopes.push({ name, changeType: 'ADDED', after: afterMembers });
+            }
+            else if (!afterMembers) {
+                scopes.push({ name, changeType: 'REMOVED', before: beforeMembers });
+            }
+            else if (JSON.stringify(beforeMembers.sort()) !== JSON.stringify(afterMembers.sort())) {
+                scopes.push({ name, changeType: 'MODIFIED', before: beforeMembers, after: afterMembers });
+            }
+        }
+        // Compare start/exit ports
+        const startPorts = compareWorkflowPorts(before.startPorts, after.startPorts);
+        const exitPorts = compareWorkflowPorts(before.exitPorts, after.exitPorts);
+        // Calculate summary
+        const modifiedInstances = instances.filter(i => i.changeType === 'MODIFIED');
+        const summary = {
+            nodeTypesAdded: nodeTypes.filter(nt => nt.changeType === 'ADDED').length,
+            nodeTypesRemoved: nodeTypes.filter(nt => nt.changeType === 'REMOVED').length,
+            nodeTypesModified: nodeTypes.filter(nt => nt.changeType === 'MODIFIED').length,
+            instancesAdded: instances.filter(i => i.changeType === 'ADDED').length,
+            instancesRemoved: instances.filter(i => i.changeType === 'REMOVED').length,
+            instancesModified: modifiedInstances.filter(i => i.changes.nodeType || i.changes.config || i.changes.parent).length,
+            instancesUIModified: modifiedInstances.filter(i => i.changes.ui).length,
+            connectionsAdded: connections.filter(c => c.changeType === 'ADDED').length,
+            connectionsRemoved: connections.filter(c => c.changeType === 'REMOVED').length,
+        };
+        // Check if identical
+        const identical = nodeTypes.length === 0 &&
+            instances.length === 0 &&
+            connections.length === 0 &&
+            scopes.length === 0 &&
+            startPorts.added.length === 0 &&
+            startPorts.removed.length === 0 &&
+            startPorts.modified.length === 0 &&
+            exitPorts.added.length === 0 &&
+            exitPorts.removed.length === 0 &&
+            exitPorts.modified.length === 0;
+        const partialDiff = {
+            identical,
+            summary,
+            nodeTypes,
+            instances,
+            connections,
+            startPorts,
+            exitPorts,
+            scopes,
+        };
+        return {
+            ...partialDiff,
+            impact: identical ? 'COSMETIC' : calculateImpact(partialDiff),
+        };
+    }
+}
+//# sourceMappingURL=WorkflowDiffer.js.map

package/dist/diff/formatDiff.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Human-readable diff formatter for workflow diffs.
+ */
+import type { TWorkflowDiff } from './types.js';
+export type TDiffFormat = 'text' | 'json' | 'compact';
+/**
+ * Format a workflow diff for display
+ */
+export declare function formatDiff(diff: TWorkflowDiff, format?: TDiffFormat): string;
+//# sourceMappingURL=formatDiff.d.ts.map

package/dist/diff/formatDiff.js

@@ -0,0 +1,220 @@
+/**
+ * Human-readable diff formatter for workflow diffs.
+ */
+import { IMPACT_DESCRIPTIONS, getImpactReasons } from './impact.js';
+/**
+ * Format a workflow diff for display
+ */
+export function formatDiff(diff, format = 'text') {
+    switch (format) {
+        case 'json':
+            return JSON.stringify(diff, null, 2);
+        case 'compact':
+            return formatCompact(diff);
+        case 'text':
+        default:
+            return formatText(diff);
+    }
+}
+/**
+ * Compact single-line format
+ */
+function formatCompact(diff) {
+    if (diff.identical) {
+        return 'No changes';
+    }
+    const parts = [];
+    const { summary } = diff;
+    if (summary.nodeTypesAdded > 0)
+        parts.push(`+${summary.nodeTypesAdded} types`);
+    if (summary.nodeTypesRemoved > 0)
+        parts.push(`-${summary.nodeTypesRemoved} types`);
+    if (summary.nodeTypesModified > 0)
+        parts.push(`~${summary.nodeTypesModified} types`);
+    if (summary.instancesAdded > 0)
+        parts.push(`+${summary.instancesAdded} nodes`);
+    if (summary.instancesRemoved > 0)
+        parts.push(`-${summary.instancesRemoved} nodes`);
+    if (summary.instancesModified > 0)
+        parts.push(`~${summary.instancesModified} nodes`);
+    if (summary.connectionsAdded > 0)
+        parts.push(`+${summary.connectionsAdded} conns`);
+    if (summary.connectionsRemoved > 0)
+        parts.push(`-${summary.connectionsRemoved} conns`);
+    return `[${diff.impact}] ${parts.join(', ')}`;
+}
+/**
+ * Full text format
+ */
+function formatText(diff) {
+    const lines = [];
+    // Header
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push(`  WORKFLOW DIFF - Impact: ${diff.impact}`);
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+    if (diff.identical) {
+        lines.push('  ✓ Workflows are semantically identical');
+        lines.push('');
+        return lines.join('\n');
+    }
+    // Impact description
+    lines.push(`  ${IMPACT_DESCRIPTIONS[diff.impact]}`);
+    lines.push('');
+    // Summary
+    lines.push('  SUMMARY');
+    lines.push('  ───────────────────────────────────────────────────────────');
+    lines.push(`  Node Types:   +${diff.summary.nodeTypesAdded} added, -${diff.summary.nodeTypesRemoved} removed, ~${diff.summary.nodeTypesModified} modified`);
+    lines.push(`  Instances:    +${diff.summary.instancesAdded} added, -${diff.summary.instancesRemoved} removed, ~${diff.summary.instancesModified} modified`);
+    lines.push(`  Connections:  +${diff.summary.connectionsAdded} added, -${diff.summary.connectionsRemoved} removed`);
+    lines.push('');
+    // Node Types
+    if (diff.nodeTypes.length > 0) {
+        lines.push('  NODE TYPES');
+        lines.push('  ───────────────────────────────────────────────────────────');
+        for (const nt of diff.nodeTypes) {
+            lines.push(formatNodeType(nt));
+        }
+        lines.push('');
+    }
+    // Instances
+    if (diff.instances.length > 0) {
+        lines.push('  INSTANCES');
+        lines.push('  ───────────────────────────────────────────────────────────');
+        for (const inst of diff.instances) {
+            lines.push(formatInstance(inst));
+        }
+        lines.push('');
+    }
+    // Connections
+    if (diff.connections.length > 0) {
+        lines.push('  CONNECTIONS');
+        lines.push('  ───────────────────────────────────────────────────────────');
+        for (const conn of diff.connections) {
+            lines.push(formatConnection(conn));
+        }
+        lines.push('');
+    }
+    // Start/Exit Ports
+    const hasPortChanges = diff.startPorts.added.length > 0 ||
+        diff.startPorts.removed.length > 0 ||
+        diff.startPorts.modified.length > 0 ||
+        diff.exitPorts.added.length > 0 ||
+        diff.exitPorts.removed.length > 0 ||
+        diff.exitPorts.modified.length > 0;
+    if (hasPortChanges) {
+        lines.push('  WORKFLOW PORTS');
+        lines.push('  ───────────────────────────────────────────────────────────');
+        if (diff.startPorts.added.length > 0) {
+            lines.push(`  + Start ports added: ${diff.startPorts.added.map(p => p.name).join(', ')}`);
+        }
+        if (diff.startPorts.removed.length > 0) {
+            lines.push(`  - Start ports removed: ${diff.startPorts.removed.map(p => p.name).join(', ')}`);
+        }
+        if (diff.startPorts.modified.length > 0) {
+            lines.push(`  ~ Start ports modified: ${diff.startPorts.modified.map(p => p.name).join(', ')}`);
+        }
+        if (diff.exitPorts.added.length > 0) {
+            lines.push(`  + Exit ports added: ${diff.exitPorts.added.map(p => p.name).join(', ')}`);
+        }
+        if (diff.exitPorts.removed.length > 0) {
+            lines.push(`  - Exit ports removed: ${diff.exitPorts.removed.map(p => p.name).join(', ')}`);
+        }
+        if (diff.exitPorts.modified.length > 0) {
+            lines.push(`  ~ Exit ports modified: ${diff.exitPorts.modified.map(p => p.name).join(', ')}`);
+        }
+        lines.push('');
+    }
+    // Scopes
+    if (diff.scopes.length > 0) {
+        lines.push('  SCOPES');
+        lines.push('  ───────────────────────────────────────────────────────────');
+        for (const scope of diff.scopes) {
+            const symbol = scope.changeType === 'ADDED' ? '+' : scope.changeType === 'REMOVED' ? '-' : '~';
+            lines.push(`  ${symbol} ${scope.name}`);
+        }
+        lines.push('');
+    }
+    // Reasons
+    const reasons = getImpactReasons(diff);
+    if (reasons.length > 0) {
+        lines.push('  CHANGE DETAILS');
+        lines.push('  ───────────────────────────────────────────────────────────');
+        for (const reason of reasons) {
+            lines.push(`  • ${reason}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function formatNodeType(nt) {
+    const symbol = nt.changeType === 'ADDED' ? '+' : nt.changeType === 'REMOVED' ? '-' : '~';
+    let line = `  ${symbol} ${nt.name}`;
+    if (nt.changeType === 'MODIFIED') {
+        const details = [];
+        if (nt.changes.functionName)
+            details.push(`functionName: ${nt.changes.functionName.before} → ${nt.changes.functionName.after}`);
+        if (nt.changes.isAsync)
+            details.push(`async: ${nt.changes.isAsync.before} → ${nt.changes.isAsync.after}`);
+        if (nt.changes.executeWhen)
+            details.push(`executeWhen: ${nt.changes.executeWhen.before} → ${nt.changes.executeWhen.after}`);
+        if (nt.changes.inputs) {
+            const added = nt.changes.inputs.filter(p => p.type === 'ADDED').map(p => p.portName);
+            const removed = nt.changes.inputs.filter(p => p.type === 'REMOVED').map(p => p.portName);
+            const modified = nt.changes.inputs.filter(p => p.type === 'MODIFIED').map(p => p.portName);
+            if (added.length > 0)
+                details.push(`+inputs: ${added.join(', ')}`);
+            if (removed.length > 0)
+                details.push(`-inputs: ${removed.join(', ')}`);
+            if (modified.length > 0)
+                details.push(`~inputs: ${modified.join(', ')}`);
+        }
+        if (nt.changes.outputs) {
+            const added = nt.changes.outputs.filter(p => p.type === 'ADDED').map(p => p.portName);
+            const removed = nt.changes.outputs.filter(p => p.type === 'REMOVED').map(p => p.portName);
+            const modified = nt.changes.outputs.filter(p => p.type === 'MODIFIED').map(p => p.portName);
+            if (added.length > 0)
+                details.push(`+outputs: ${added.join(', ')}`);
+            if (removed.length > 0)
+                details.push(`-outputs: ${removed.join(', ')}`);
+            if (modified.length > 0)
+                details.push(`~outputs: ${modified.join(', ')}`);
+        }
+        if (details.length > 0) {
+            line += ` (${details.join('; ')})`;
+        }
+    }
+    return line;
+}
+function formatInstance(inst) {
+    const symbol = inst.changeType === 'ADDED' ? '+' : inst.changeType === 'REMOVED' ? '-' : '~';
+    let line = `  ${symbol} ${inst.id}`;
+    if (inst.changeType === 'MODIFIED') {
+        const details = [];
+        if (inst.changes.nodeType) {
+            details.push(`type: ${inst.changes.nodeType.before} → ${inst.changes.nodeType.after}`);
+        }
+        if (inst.changes.parent) {
+            const before = inst.changes.parent.before ? `${inst.changes.parent.before.id}.${inst.changes.parent.before.scope}` : 'none';
+            const after = inst.changes.parent.after ? `${inst.changes.parent.after.id}.${inst.changes.parent.after.scope}` : 'none';
+            details.push(`parent: ${before} → ${after}`);
+        }
+        if (inst.changes.config?.pullExecution) {
+            details.push(`pullExecution changed`);
+        }
+        if (inst.changes.config?.portConfigs) {
+            details.push(`portConfigs changed`);
+        }
+        if (details.length > 0) {
+            line += ` (${details.join('; ')})`;
+        }
+    }
+    return line;
+}
+function formatConnection(conn) {
+    const symbol = conn.changeType === 'ADDED' ? '+' : '-';
+    const fromScope = conn.from.scope ? `:${conn.from.scope}` : '';
+    const toScope = conn.to.scope ? `:${conn.to.scope}` : '';
+    return `  ${symbol} ${conn.from.node}.${conn.from.port}${fromScope} → ${conn.to.node}.${conn.to.port}${toScope}`;
+}
+//# sourceMappingURL=formatDiff.js.map

package/dist/diff/impact.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Impact assessment utilities for workflow diffs.
+ */
+import type { TWorkflowDiff, TImpactLevel, TNodeTypeDiff, TConnectionDiff } from './types.js';
+/** Impact level descriptions */
+export declare const IMPACT_DESCRIPTIONS: Record<TImpactLevel, string>;
+/** Impact level colors for CLI/UI */
+export declare const IMPACT_COLORS: Record<TImpactLevel, string>;
+/**
+ * Get detailed impact reasons from a diff
+ */
+export declare function getImpactReasons(diff: TWorkflowDiff): string[];
+/**
+ * Check if a diff has breaking changes
+ */
+export declare function hasBreakingChanges(diff: TWorkflowDiff): boolean;
+/**
+ * Get changed node types grouped by change type
+ */
+export declare function getNodeTypeChanges(diff: TWorkflowDiff): {
+    added: TNodeTypeDiff[];
+    removed: TNodeTypeDiff[];
+    modified: TNodeTypeDiff[];
+};
+/**
+ * Get critical connections (to/from Start/Exit)
+ */
+export declare function getCriticalConnections(diff: TWorkflowDiff): TConnectionDiff[];
+//# sourceMappingURL=impact.d.ts.map