@graph-ir/core 0.2.0 → 0.2.2

package/dist/skills/migrate.js

@@ -1,287 +1,530 @@
-/**
- * IR Migrate Skill
- *
- * Migrate Graph-IR files between schema versions.
- */
-// Current schema version
-const CURRENT_VERSION = '1.0.0';
-// Define migrations between versions
-const MIGRATIONS = [
-    // Example: 0.9.0 -> 1.0.0
-    {
-        fromVersion: '0.9.0',
-        toVersion: '1.0.0',
-        changes: [
-            {
-                type: 'rename',
-                path: 'nodes[*].props',
-                description: 'Rename "props" to "properties"',
-            },
-            {
-                type: 'rename',
-                path: 'edges[*].from',
-                description: 'Rename "from" to "source"',
-            },
-            {
-                type: 'rename',
-                path: 'edges[*].to',
-                description: 'Rename "to" to "target"',
-            },
-            {
-                type: 'add',
-                path: 'edges[*].id',
-                description: 'Add required edge IDs',
-            },
-        ],
-        migrate: (ir) => {
-            const result = { ...ir };
-            // Rename node props -> properties
-            if (Array.isArray(result.nodes)) {
-                result.nodes = result.nodes.map((node, index) => {
-                    const newNode = { ...node };
-                    if ('props' in newNode) {
-                        newNode.properties = newNode.props;
-                        delete newNode.props;
-                    }
-                    return newNode;
-                });
-            }
-            // Rename edge from/to -> source/target and add IDs
-            if (Array.isArray(result.edges)) {
-                result.edges = result.edges.map((edge, index) => {
-                    const newEdge = { ...edge };
-                    if ('from' in newEdge) {
-                        newEdge.source = newEdge.from;
-                        delete newEdge.from;
-                    }
-                    if ('to' in newEdge) {
-                        newEdge.target = newEdge.to;
-                        delete newEdge.to;
-                    }
-                    if (!('id' in newEdge)) {
-                        newEdge.id = `e${index + 1}`;
-                    }
-                    return newEdge;
+import Ajv2020Import from 'ajv/dist/2020.js';
+import { validateIR } from '../validation/validator.js';
+import graphIR2Schema from '../schemas/graph-ir-2.0.schema.json' with { type: 'json' };
+const Ajv2020 = Ajv2020Import.default ??
+    Ajv2020Import;
+const validateGraphIR2Schema = new Ajv2020({
+    allErrors: true, strict: false, validateFormats: false,
+}).compile(graphIR2Schema);
+export function migrateGraphIR2To3(input, options = {}) {
+    const changes = [];
+    const losses = [];
+    const diagnostics = [];
+    const finish = (candidate) => {
+        const errors = diagnostics
+            .filter((entry) => entry.severity === 'error')
+            .map((entry) => `${entry.code} ${entry.path || '/'}: ${entry.message}`);
+        const warnings = diagnostics
+            .filter((entry) => entry.severity === 'warning')
+            .map((entry) => `${entry.code} ${entry.path || '/'}: ${entry.message}`);
+        const success = errors.length === 0;
+        return {
+            success,
+            migrated: success && !options.dryRun ? candidate : null,
+            fromVersion: '2.0.0',
+            toVersion: '3.0.0',
+            changes,
+            losses,
+            diagnostics,
+            errors,
+            warnings,
+        };
+    };
+    if (!isRecord(input) || input.version !== '2.0.0') {
+        diagnostics.push({
+            severity: 'error', code: 'MIGRATION_SOURCE_VERSION', path: '/version',
+            message: 'migrateGraphIR2To3 accepts only frozen GraphIR 2.0.0 input',
+        });
+        return finish(null);
+    }
+    if (!validateGraphIR2Schema(input)) {
+        for (const error of validateGraphIR2Schema.errors ?? []) {
+            const suffix = error.keyword === 'required'
+                ? `/${escapePointer(String(error.params.missingProperty))}` : '';
+            diagnostics.push({
+                severity: 'error', code: 'MIGRATION_SOURCE_INVALID',
+                path: `${error.instancePath}${suffix}`,
+                message: error.message ?? 'Invalid GraphIR 2 migration input',
+            });
+        }
+        return finish(null);
+    }
+    const working = structuredClone(input);
+    working.version = '3.0.0';
+    changes.push({
+        code: 'SET_SCHEMA_VERSION', path: '/version',
+        message: 'Set serialized schema version to 3.0.0', value: '3.0.0',
+    });
+    const notation = typeof working.metadata?.notation === 'string'
+        ? working.metadata.notation : undefined;
+    const diagramType = typeof working.metadata?.custom?.diagramType === 'string'
+        ? working.metadata.custom.diagramType : undefined;
+    const notationKind = notation === 'uml-class' ? 'class'
+        : notation === 'uml-sequence' ? 'sequence' : undefined;
+    const customKind = diagramType === 'class' ? 'class'
+        : diagramType === 'sequence' ? 'sequence' : undefined;
+    if (notationKind && customKind && notationKind !== customKind) {
+        diagnostics.push({
+            severity: 'error', code: 'MIGRATION_PROFILE_CONTRADICTION',
+            path: '/metadata/custom/diagramType',
+            message: 'Recognized notation and diagramType select different profiles',
+        });
+        return finish(null);
+    }
+    const profileKind = notationKind ?? customKind;
+    if (profileKind) {
+        working.profile = { id: 'uml', kind: profileKind, version: '1.0.0' };
+        changes.push({
+            code: 'CREATE_NOTATION_PROFILE', path: '/profile',
+            sourcePath: notationKind ? '/metadata/notation' : '/metadata/custom/diagramType',
+            message: `Create UML ${profileKind} notation profile`, value: working.profile,
+        });
+    }
+    for (const [value, path, recognized] of [
+        [notation, '/metadata/notation', ['uml-class', 'uml-sequence']],
+        [diagramType, '/metadata/custom/diagramType', ['class', 'sequence']],
+    ]) {
+        if (value !== undefined && !recognized.includes(value)) {
+            losses.push({
+                code: 'UNKNOWN_LEGACY_NOTATION', path,
+                message: `Unknown legacy notation value ${value} was preserved`, value,
+            });
+            diagnostics.push({
+                severity: 'warning', code: 'UNKNOWN_LEGACY_NOTATION', path,
+                message: `Unknown legacy notation value ${value} did not create a profile`,
+            });
+        }
+    }
+    if (Array.isArray(working.edges)) {
+        working.edges.forEach((edge, index) => {
+            if (!isRecord(edge) || !isRecord(edge.style))
+                return;
+            for (const [field, end] of [['sourceArrow', 'sourceEnd'], ['targetArrow', 'targetEnd']]) {
+                if (typeof edge.style[field] !== 'string')
+                    continue;
+                edge[end] = { marker: { kind: edge.style[field], fill: 'unspecified' } };
+                delete edge.style[field];
+                changes.push({
+                    code: 'CONVERT_ENDPOINT_MARKER', path: `/edges/${index}/${end}/marker`,
+                    sourcePath: `/edges/${index}/style/${field}`,
+                    message: `Convert legacy ${field} to relationship-end marker`, value: edge[end],
                 });
             }
-            result.version = '1.0.0';
-            return result;
-        },
-    },
-    // Example: 0.8.0 -> 0.9.0
-    {
-        fromVersion: '0.8.0',
-        toVersion: '0.9.0',
-        changes: [
-            {
-                type: 'add',
-                path: 'version',
-                description: 'Add required version field',
-                value: '0.9.0',
-            },
-            {
-                type: 'add',
-                path: 'id',
-                description: 'Add required graph ID',
-            },
-        ],
-        migrate: (ir) => {
-            const result = { ...ir };
-            if (!result.version) {
-                result.version = '0.9.0';
+            if (Object.keys(edge.style).length === 0)
+                delete edge.style;
+        });
+    }
+    if (profileKind === 'class') {
+        visitNodes(working.nodes, '/nodes', (node, path) => {
+            const members = isRecord(node.properties) && Array.isArray(node.properties.members)
+                ? node.properties.members : undefined;
+            if (!members)
+                return;
+            const parsed = members.map((value, index) => ({
+                value,
+                sourcePath: `${path}/properties/members/${index}`,
+                member: typeof value === 'string'
+                    ? parseClassifierMember(value, `${path}/properties/members/${index}`) : null,
+            }));
+            const ambiguous = parsed.filter((entry) => entry.member === null);
+            if (ambiguous.length > 0) {
+                for (const entry of ambiguous) {
+                    losses.push({
+                        code: 'AMBIGUOUS_CLASSIFIER_MEMBER', path: entry.sourcePath,
+                        message: 'Classifier member could not be converted without guessing',
+                        value: entry.value,
+                    });
+                    diagnostics.push({
+                        severity: 'error', code: 'AMBIGUOUS_CLASSIFIER_MEMBER',
+                        path: entry.sourcePath,
+                        message: 'Classifier member must match the conservative grammar',
+                    });
+                }
+                return;
             }
-            if (!result.id) {
-                result.id = 'migrated-graph';
+            const attributes = parsed.map((entry) => entry.member)
+                .filter((value) => value?.kind === 'attribute');
+            const operations = parsed.map((entry) => entry.member)
+                .filter((value) => value?.kind === 'operation');
+            const compartments = [{ id: `${node.id}-name`, kind: 'name' }];
+            if (attributes.length > 0)
+                compartments.push({
+                    id: `${node.id}-attributes`, kind: 'attributes', items: attributes,
+                });
+            if (operations.length > 0)
+                compartments.push({
+                    id: `${node.id}-operations`, kind: 'operations', items: operations,
+                });
+            node.classifier = {
+                kind: 'class', name: typeof node.label === 'string' && node.label.length > 0 ? node.label : node.id,
+                compartments,
+            };
+            changes.push({
+                code: 'CONVERT_CLASSIFIER_MEMBERS', path: `${path}/classifier`,
+                sourcePath: `${path}/properties/members`,
+                message: 'Convert unambiguous raw members to structured classifier compartments',
+                value: node.classifier,
+            });
+            for (const entry of parsed) {
+                changes.push({
+                    code: 'CONVERT_CLASSIFIER_MEMBER', path: `${path}/classifier`,
+                    sourcePath: entry.sourcePath,
+                    message: 'Convert one raw classifier member to structured meaning',
+                    value: entry.value,
+                });
             }
-            return result;
-        },
-    },
-];
-/**
- * Migrate a Graph-IR to the target version
- */
-export function migrateIR(ir, options = {}) {
-    const errors = [];
-    const warnings = [];
-    const allChanges = [];
-    // Detect source version
-    const fromVersion = options.fromVersion || detectVersion(ir);
-    const toVersion = options.toVersion || CURRENT_VERSION;
-    if (!fromVersion) {
-        return {
-            success: false,
-            migrated: null,
-            fromVersion: 'unknown',
-            toVersion,
-            changes: [],
-            errors: ['Could not detect source version. Please specify --from <version>'],
-            warnings: [],
+        });
+    }
+    if (profileKind === 'sequence') {
+        const participants = [];
+        visitNodes(working.nodes, '/nodes', (node, path) => {
+            if (typeof node.id !== 'string')
+                return;
+            participants.push({ id: node.id, nodeId: node.id });
+            changes.push({
+                code: 'DERIVE_PARTICIPANT_ORDER', path: `/interaction/participantOrder/${participants.length - 1}`,
+                sourcePath: `${path}/id`, message: 'Derive participant identity and order', value: node.id,
+            });
+        });
+        const messages = working.edges.map((edge, index) => {
+            changes.push({
+                code: 'DERIVE_MESSAGE_ORDER', path: `/interaction/messageOrder/${index}`,
+                sourcePath: `/edges/${index}/id`, message: 'Derive message identity and order', value: edge.id,
+            });
+            return {
+                id: edge.id, edgeId: edge.id,
+                sourceParticipantId: edge.source, targetParticipantId: edge.target,
+            };
+        });
+        working.interaction = {
+            participants,
+            participantOrder: participants.map((participant) => participant.id),
+            messages,
+            messageOrder: messages.map((message) => message.id),
         };
     }
-    // Already at target version?
-    if (fromVersion === toVersion) {
+    if (diagnostics.some((entry) => entry.severity === 'error'))
+        return finish(null);
+    const candidate = working;
+    const validation = validateIR(candidate);
+    for (const error of validation.errors) {
+        diagnostics.push({
+            severity: 'error', code: `MIGRATION_${error.code}`, path: error.path,
+            message: error.message,
+        });
+    }
+    for (const warning of validation.warnings) {
+        diagnostics.push({
+            severity: 'warning', code: `MIGRATION_${warning.code}`, path: warning.path,
+            message: warning.message,
+        });
+    }
+    return finish(candidate);
+}
+const CURRENT_VERSION = '2.0.0';
+export function migrateIR(input, options = {}) {
+    const fromVersion = options.fromVersion ?? detectVersion(input);
+    const toVersion = options.toVersion ?? CURRENT_VERSION;
+    if (!fromVersion || !isRecord(input)) {
+        return failure(fromVersion ?? 'unknown', toVersion, ['Could not detect source version. Specify fromVersion explicitly.']);
+    }
+    if (toVersion !== CURRENT_VERSION) {
+        return failure(fromVersion, toVersion, [`Unsupported migration target ${toVersion}`]);
+    }
+    if (fromVersion === CURRENT_VERSION) {
+        const candidate = structuredClone(input);
+        const validationErrors = validateMigrationCandidate(candidate);
+        if (validationErrors.length > 0) {
+            return invalidCandidate(fromVersion, toVersion, [], [], validationErrors);
+        }
         return {
             success: true,
-            migrated: ir,
+            migrated: options.dryRun ? null : candidate,
             fromVersion,
             toVersion,
             changes: [],
+            losses: [],
             errors: [],
             warnings: ['Already at target version'],
         };
     }
-    // Build migration path
-    const path = buildMigrationPath(fromVersion, toVersion);
-    if (path.length === 0) {
+    let working = structuredClone(input);
+    const changes = [];
+    if (fromVersion === '0.8.0' || fromVersion === '0.9.0') {
+        working = normalizeLegacyToOne(working, changes);
+    }
+    else if (fromVersion !== '1.0.0') {
+        return failure(fromVersion, toVersion, [`No migration path from ${fromVersion}`]);
+    }
+    const losses = collectAmbiguousLosses(working);
+    if (losses.length > 0 && (options.ambiguousGeometry ?? 'error') === 'error') {
         return {
             success: false,
             migrated: null,
             fromVersion,
             toVersion,
-            changes: [],
-            errors: [`No migration path found from ${fromVersion} to ${toVersion}`],
+            changes,
+            losses,
+            errors: [
+                'Schema 1.x geometry has ambiguous provenance; choose ambiguousGeometry="drop" or migrate with producer-owned provenance.',
+            ],
             warnings: [],
         };
     }
-    // Apply migrations
-    let current = ir;
-    for (const migration of path) {
-        allChanges.push(...migration.changes);
-        if (!options.dryRun) {
-            try {
-                current = migration.migrate(current);
-            }
-            catch (e) {
-                const errorMsg = e instanceof Error ? e.message : 'Unknown migration error';
-                if (options.force) {
-                    warnings.push(`Migration ${migration.fromVersion} → ${migration.toVersion} failed: ${errorMsg}`);
-                }
-                else {
-                    return {
-                        success: false,
-                        migrated: null,
-                        fromVersion,
-                        toVersion,
-                        changes: allChanges,
-                        errors: [`Migration failed at ${migration.fromVersion} → ${migration.toVersion}: ${errorMsg}`],
-                        warnings,
-                    };
-                }
-            }
-        }
+    if (losses.length > 0) {
+        removeAmbiguousGeometry(working, changes);
+    }
+    promoteEdgeDescriptions(working, changes);
+    working.version = CURRENT_VERSION;
+    changes.push({
+        type: 'transform',
+        path: '/version',
+        description: 'Set serialized schema version to 2.0.0',
+        value: CURRENT_VERSION,
+    });
+    const candidate = working;
+    const validationErrors = validateMigrationCandidate(candidate);
+    if (validationErrors.length > 0) {
+        return invalidCandidate(fromVersion, toVersion, changes, losses, validationErrors);
     }
     return {
         success: true,
-        migrated: options.dryRun ? null : current,
+        migrated: options.dryRun ? null : candidate,
         fromVersion,
         toVersion,
-        changes: allChanges,
-        errors,
-        warnings,
+        changes,
+        losses,
+        errors: [],
+        warnings: losses.map((loss) => `Dropped ambiguous ${loss.field} at ${loss.path}`),
     };
 }
-/**
- * Detect the version of a Graph-IR object
- */
-function detectVersion(ir) {
-    if (!ir || typeof ir !== 'object') {
-        return null;
+function validateMigrationCandidate(candidate) {
+    if (validateGraphIR2Schema(candidate))
+        return [];
+    return (validateGraphIR2Schema.errors ?? []).map((error) => {
+        const suffix = error.keyword === 'additionalProperties'
+            ? `/${escapePointer(String(error.params.additionalProperty))}` : '';
+        return `SCHEMA_VIOLATION ${error.instancePath}${suffix || (error.instancePath ? '' : '/')}: ${error.message ?? 'invalid GraphIR 2'}`;
+    });
+}
+function invalidCandidate(fromVersion, toVersion, changes, losses, errors) {
+    return {
+        success: false,
+        migrated: null,
+        fromVersion,
+        toVersion,
+        changes,
+        losses,
+        errors: ['Migrated candidate is not valid GraphIR 2.0.0', ...errors],
+        warnings: losses.map((loss) => `Would drop ambiguous ${loss.field} at ${loss.path}`),
+    };
+}
+function normalizeLegacyToOne(input, changes) {
+    const result = { ...input };
+    if (!result.id) {
+        result.id = 'migrated-graph';
+        changes.push({ type: 'add', path: '/id', description: 'Add graph ID' });
+    }
+    if (Array.isArray(result.nodes)) {
+        result.nodes = result.nodes.map((value) => {
+            if (!isRecord(value))
+                return value;
+            const node = { ...value };
+            if ('props' in node && !('properties' in node)) {
+                node.properties = node.props;
+                delete node.props;
+                changes.push({ type: 'rename', path: '/nodes/*/props', description: 'Rename props to properties' });
+            }
+            return node;
+        });
     }
-    const obj = ir;
-    // Check explicit version field
-    if (typeof obj.version === 'string') {
-        return obj.version;
+    if (Array.isArray(result.edges)) {
+        result.edges = result.edges.map((value, index) => {
+            if (!isRecord(value))
+                return value;
+            const edge = { ...value };
+            if ('from' in edge && !('source' in edge)) {
+                edge.source = edge.from;
+                delete edge.from;
+            }
+            if ('to' in edge && !('target' in edge)) {
+                edge.target = edge.to;
+                delete edge.to;
+            }
+            if (!edge.id)
+                edge.id = `e${index + 1}`;
+            return edge;
+        });
+        changes.push({ type: 'transform', path: '/edges', description: 'Normalize legacy edge fields and IDs' });
     }
-    // Infer version from structure
-    if (Array.isArray(obj.nodes) && obj.nodes.length > 0) {
-        const firstNode = obj.nodes[0];
-        // v0.9.0: has 'props' instead of 'properties'
-        if ('props' in firstNode && !('properties' in firstNode)) {
-            return '0.9.0';
+    result.version = '1.0.0';
+    return result;
+}
+function collectAmbiguousLosses(input) {
+    const losses = [];
+    visitNodes(input.nodes, '/nodes', (node, path) => {
+        for (const field of ['position', 'pinned', 'dimensions']) {
+            if (field in node) {
+                losses.push({
+                    path: `${path}/${field}`,
+                    field,
+                    reason: `Schema 1.x ${field} did not distinguish authored and computed geometry`,
+                });
+            }
         }
+    });
+    if (Array.isArray(input.edges)) {
+        input.edges.forEach((value, index) => {
+            if (isRecord(value) && 'routingPoints' in value) {
+                losses.push({
+                    path: `/edges/${index}/routingPoints`,
+                    field: 'routingPoints',
+                    reason: 'Schema 1.x routing points did not distinguish authored waypoints and generated bends',
+                });
+            }
+        });
+    }
+    if (isRecord(input.layoutOptions) && 'algorithmOptions' in input.layoutOptions) {
+        losses.push({
+            path: '/layoutOptions/algorithmOptions',
+            field: 'algorithmOptions',
+            reason: 'Raw engine options are not portable authored GraphIR 2.0',
+        });
     }
-    if (Array.isArray(obj.edges) && obj.edges.length > 0) {
-        const firstEdge = obj.edges[0];
-        // v0.9.0: has 'from'/'to' instead of 'source'/'target'
-        if (('from' in firstEdge || 'to' in firstEdge) &&
-            !('source' in firstEdge || 'target' in firstEdge)) {
-            return '0.9.0';
+    return losses;
+}
+function removeAmbiguousGeometry(input, changes) {
+    visitNodes(input.nodes, '/nodes', (node, path) => {
+        for (const field of ['position', 'pinned', 'dimensions']) {
+            if (field in node) {
+                delete node[field];
+                changes.push({ type: 'remove', path: `${path}/${field}`, description: `Drop ambiguous ${field}` });
+            }
         }
+    });
+    if (Array.isArray(input.edges)) {
+        input.edges.forEach((value, index) => {
+            if (isRecord(value) && 'routingPoints' in value) {
+                delete value.routingPoints;
+                changes.push({ type: 'remove', path: `/edges/${index}/routingPoints`, description: 'Drop ambiguous routing points' });
+            }
+        });
     }
-    // No version field but has modern structure
-    if (!obj.version && obj.id && Array.isArray(obj.nodes) && Array.isArray(obj.edges)) {
-        // Could be 1.0.0 without version field
-        return '1.0.0';
+    if (isRecord(input.layoutOptions) && 'algorithmOptions' in input.layoutOptions) {
+        delete input.layoutOptions.algorithmOptions;
+        changes.push({ type: 'remove', path: '/layoutOptions/algorithmOptions', description: 'Drop non-portable engine options' });
     }
-    // Very old version without id field
-    if (!obj.id && !obj.version) {
+}
+function promoteEdgeDescriptions(input, changes) {
+    if (!Array.isArray(input.edges))
+        return;
+    input.edges.forEach((value, index) => {
+        if (!isRecord(value) || value.description !== undefined || !isRecord(value.properties))
+            return;
+        if (typeof value.properties.description !== 'string')
+            return;
+        value.description = value.properties.description;
+        delete value.properties.description;
+        if (Object.keys(value.properties).length === 0)
+            delete value.properties;
+        changes.push({
+            type: 'transform',
+            path: `/edges/${index}/description`,
+            description: 'Promote unambiguous properties.description',
+        });
+    });
+}
+function visitNodes(value, path, visit) {
+    if (!Array.isArray(value))
+        return;
+    value.forEach((candidate, index) => {
+        if (!isRecord(candidate))
+            return;
+        const nodePath = `${path}/${index}`;
+        visit(candidate, nodePath);
+        visitNodes(candidate.children, `${nodePath}/children`, visit);
+    });
+}
+function detectVersion(input) {
+    if (!isRecord(input))
+        return null;
+    if (typeof input.version === 'string')
+        return input.version;
+    if (!input.id)
         return '0.8.0';
-    }
+    if (Array.isArray(input.nodes) || Array.isArray(input.edges))
+        return '0.9.0';
     return null;
 }
-/**
- * Build the migration path from source to target version
- */
-function buildMigrationPath(from, to) {
-    const path = [];
-    let current = from;
-    // Simple linear search - could be optimized with graph traversal
-    while (current !== to) {
-        const migration = MIGRATIONS.find((m) => m.fromVersion === current);
-        if (!migration) {
-            break;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function escapePointer(value) {
+    return value.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function parseClassifierMember(raw, path) {
+    const visibilityMap = {
+        '+': 'public', '#': 'protected', '-': 'private', '~': 'package',
+    };
+    const ordinal = Number(path.split('/').at(-1) ?? 0);
+    const operation = raw.match(/^([+#~-])?\s*([A-Za-z_][A-Za-z0-9_-]*)\s*\(([^)]*)\)\s*(?::\s*([^\s,:()]+))?$/);
+    if (operation) {
+        const [, visibility, name, parameterText, returnType] = operation;
+        const parameters = [];
+        if (parameterText.trim().length > 0) {
+            for (const rawParameter of parameterText.split(',')) {
+                const parameter = rawParameter.trim().match(/^([A-Za-z_][A-Za-z0-9_-]*)(?:\s*:\s*([^\s,:()]+))?$/);
+                if (!parameter)
+                    return null;
+                parameters.push({
+                    name: parameter[1], ...(parameter[2] ? { type: parameter[2] } : {}),
+                });
+            }
         }
-        path.push(migration);
-        current = migration.toVersion;
+        return {
+            id: `${name}-${ordinal}`, kind: 'operation',
+            ...(visibility ? { visibility: visibilityMap[visibility] } : {}),
+            name, parameters, ...(returnType ? { returnType } : {}),
+        };
     }
-    // Verify we reached target
-    if (current !== to) {
-        return [];
+    const attribute = raw.match(/^([+#~-])?\s*([^\s,:()]+)\s+([A-Za-z_][A-Za-z0-9_-]*)$/);
+    if (attribute) {
+        const [, visibility, type, name] = attribute;
+        return {
+            id: `${name}-${ordinal}`, kind: 'attribute',
+            ...(visibility ? { visibility: visibilityMap[visibility] } : {}),
+            name, type,
+        };
     }
-    return path;
+    return null;
+}
+function failure(fromVersion, toVersion, errors) {
+    return {
+        success: false,
+        migrated: null,
+        fromVersion,
+        toVersion,
+        changes: [],
+        losses: [],
+        errors,
+        warnings: [],
+    };
 }
-/**
- * Format migration result for display
- */
 export function formatMigrationResult(result, dryRun) {
-    const lines = [];
-    if (dryRun) {
-        lines.push('Migration Plan (Dry Run)');
-    }
-    else {
-        lines.push('Migration Result');
-    }
-    lines.push('═'.repeat(40));
-    lines.push(`Version: ${result.fromVersion} → ${result.toVersion}`);
-    lines.push('');
-    if (result.changes.length === 0) {
-        lines.push('No changes needed');
-    }
-    else {
-        lines.push(`Changes (${result.changes.length}):`);
-        for (const change of result.changes) {
-            const icon = change.type === 'add' ? '+' :
-                change.type === 'remove' ? '-' :
-                    change.type === 'rename' ? '~' : '→';
-            lines.push(`  ${icon} ${change.description}`);
-            lines.push(`    Path: ${change.path}`);
-        }
-    }
-    if (result.warnings.length > 0) {
-        lines.push('');
-        lines.push('Warnings:');
-        for (const warning of result.warnings) {
-            lines.push(`  ⚠ ${warning}`);
-        }
-    }
-    if (result.errors.length > 0) {
-        lines.push('');
-        lines.push('Errors:');
-        for (const error of result.errors) {
-            lines.push(`  ✗ ${error}`);
-        }
-    }
-    lines.push('');
+    const lines = [
+        dryRun ? 'Migration Plan (Dry Run)' : 'Migration Result',
+        '═'.repeat(40),
+        `Version: ${result.fromVersion} → ${result.toVersion}`,
+        '',
+    ];
+    for (const change of result.changes)
+        lines.push(`  ${change.type}: ${change.path} — ${change.description}`);
+    for (const loss of result.losses)
+        lines.push(`  loss: ${loss.path} — ${loss.reason}`);
+    for (const warning of result.warnings)
+        lines.push(`  warning: ${warning}`);
+    for (const error of result.errors)
+        lines.push(`  error: ${error}`);
     lines.push(result.success ? '✓ Migration successful' : '✗ Migration failed');
     return lines.join('\n');
 }