vue3-migration 1.2.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue3-migration",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Automatically migrate Vue 2 mixins to Vue 3 composables — data, computed, methods, watchers, lifecycle hooks, and all",
   "bin": {
     "vue3-migration": "./bin/cli.js"

package/vue3_migration/core/composable_analyzer.py

@@ -34,8 +34,9 @@ def extract_all_identifiers(source: str) -> list[str]:
             else:
                 ids.add(part.split("=")[0].strip())
 
-    # Return keys: return { foo, bar, baz: val }
-    ret = re.search(r"\breturn\s*\{", source)
+    # Return keys: return { foo, bar, baz: val } — use LAST match to skip nested returns
+    ret_matches = list(re.finditer(r"\breturn\s*\{", source))
+    ret = ret_matches[-1] if ret_matches else None
     if ret:
         block = extract_brace_block(source, ret.end() - 1)
         ids.update(re.findall(r"\b(\w+)\s*[,}\n:]", block))
@@ -59,8 +60,9 @@ def extract_return_keys(source: str) -> list[str]:
         "null", "undefined", "new", "value",
     }
 
-    # Case 1: direct return { ... }
-    ret = re.search(r"\breturn\s*\{", source)
+    # Case 1: direct return { ... } — use LAST match to skip nested returns
+    matches = list(re.finditer(r"\breturn\s*\{", source))
+    ret = matches[-1] if matches else None
     if ret:
         block = extract_brace_block(source, ret.end() - 1)
         keys = re.findall(r"\b(\w+)\b", block)

package/vue3_migration/core/warning_collector.py

@@ -321,7 +321,8 @@ def inject_inline_warnings(
         for line in lines:
             if not injected and w.line_hint in line:
                 indent = line[: len(line) - len(line.lstrip())]
-                new_lines.append(f"{indent}// ⚠ MIGRATION: {w.message}\n")
+                for msg_line in f"// ⚠ MIGRATION: {w.message}".splitlines():
+                    new_lines.append(f"{indent}{msg_line}\n")
                 injected = True
             new_lines.append(line)
         if injected:
@@ -331,9 +332,11 @@ def inject_inline_warnings(
 
     # Place unmatched warnings as a block after the confidence header
     if unplaced:
-        block = "".join(
-            f"// ⚠ MIGRATION: {w.message}\n" for w in unplaced
-        )
+        block_lines: list[str] = []
+        for w in unplaced:
+            for msg_line in f"// ⚠ MIGRATION: {w.message}".splitlines():
+                block_lines.append(f"{msg_line}\n")
+        block = "".join(block_lines)
         if confidence is not None:
             # Insert right after the first line (confidence header)
             idx = source.index('\n') + 1

package/vue3_migration/models.py

@@ -178,6 +178,7 @@ class MigrationPlan:
     """All planned file changes for a project-wide auto-migrate run."""
     component_changes: list["FileChange"] = field(default_factory=list)
     composable_changes: list["FileChange"] = field(default_factory=list)
+    entries_by_component: list[tuple[Path, list["MixinEntry"]]] = field(default_factory=list)
 
     @property
     def all_changes(self) -> list["FileChange"]:

package/vue3_migration/reporting/diff.py

@@ -7,6 +7,7 @@ from datetime import datetime
 from pathlib import Path
 
 from ..models import FileChange, MigrationPlan
+from .markdown import build_warning_summary
 from .terminal import bold, dim, green
 
 
@@ -188,6 +189,13 @@ def write_diff_report(plan: MigrationPlan, project_root: Path) -> Path:
         "",
     ]
 
+    # Prepend warning summary before diffs
+    if plan.entries_by_component:
+        summary = build_warning_summary(plan.entries_by_component, plan.composable_changes)
+        if summary:
+            sections.append(summary)
+            sections.append("")
+
     all_changes = [c for c in (plan.composable_changes + plan.component_changes) if c.has_changes]
 
     for change in all_changes:

package/vue3_migration/reporting/markdown.py

@@ -4,7 +4,7 @@ Markdown report generation for migration analysis results.
 
 from pathlib import Path
 
-from ..models import ConfidenceLevel, MixinEntry
+from ..models import ConfidenceLevel, FileChange, MixinEntry
 from .terminal import md_green, md_yellow
 
 
@@ -344,37 +344,97 @@ def build_audit_report(
     return "\n".join(lines)
 
 
-def build_warnings_section(
-    entries: list[MixinEntry],
-    confidence_map: dict[str, ConfidenceLevel],
+def build_warning_summary(
+    entries_by_component: "list[tuple[Path, list[MixinEntry]]]",
+    composable_changes: "list[FileChange] | None" = None,
 ) -> str:
-    """Build a markdown Migration Warnings section.
+    """Build a markdown Migration Summary checklist for the diff report.
 
-    Groups warnings by mixin, shows confidence per composable,
-    and a table of Issue | Action Required for each warning.
+    Groups warnings by mixin/composable with confidence levels, severity
+    icons, and actionable checkboxes. De-duplicates entries that share the
+    same mixin_stem (a mixin used by multiple components).
     """
-    if not entries:
+    from ..core.warning_collector import compute_confidence
+
+    # De-duplicate entries by mixin_stem (keep first occurrence)
+    seen_stems: set[str] = set()
+    unique_entries: list[MixinEntry] = []
+    for _comp_path, entry_list in entries_by_component:
+        for entry in entry_list:
+            if entry.mixin_stem not in seen_stems:
+                seen_stems.add(entry.mixin_stem)
+                unique_entries.append(entry)
+
+    if not unique_entries:
         return ""
 
-    lines: list[str] = []
-    w = lines.append
+    # Build a lookup of composable content by file path
+    composable_content_map: dict[Path, str] = {}
+    if composable_changes:
+        for change in composable_changes:
+            if change.has_changes:
+                composable_content_map[change.file_path] = change.new_content
+
+    # Compute confidence for each entry
+    confidence_map: dict[str, ConfidenceLevel] = {}
+    for entry in unique_entries:
+        comp_source = ""
+        if entry.composable and entry.composable.file_path in composable_content_map:
+            comp_source = composable_content_map[entry.composable.file_path]
+        if comp_source:
+            confidence_map[entry.mixin_stem] = compute_confidence(comp_source, entry.warnings)
+        elif any(w.severity == "error" for w in entry.warnings):
+            confidence_map[entry.mixin_stem] = ConfidenceLevel.LOW
+        elif entry.warnings:
+            confidence_map[entry.mixin_stem] = ConfidenceLevel.MEDIUM
+        else:
+            confidence_map[entry.mixin_stem] = ConfidenceLevel.HIGH
 
-    w("## Migration Warnings\n")
+    # Sort: LOW first, then MEDIUM, then HIGH (most urgent at top)
+    _CONF_ORDER = {ConfidenceLevel.LOW: 0, ConfidenceLevel.MEDIUM: 1, ConfidenceLevel.HIGH: 2}
+    unique_entries.sort(key=lambda e: _CONF_ORDER.get(confidence_map[e.mixin_stem], 2))
 
-    for entry in entries:
-        stem = entry.mixin_stem
-        confidence = confidence_map.get(stem)
-        conf_str = confidence.value if confidence else "?"
+    # Count totals
+    all_warnings = [w for e in unique_entries for w in e.warnings]
+    error_count = sum(1 for w in all_warnings if w.severity == "error")
+    warning_count = sum(1 for w in all_warnings if w.severity == "warning")
+    info_count = sum(1 for w in all_warnings if w.severity == "info")
 
-        w(f"### {stem} — Confidence: **{conf_str}**\n")
+    lines: list[str] = []
+    a = lines.append
+
+    a("## Migration Summary\n")
+
+    # Overview line
+    parts = [f"**{len(unique_entries)} composable{'s' if len(unique_entries) != 1 else ''}**"]
+    if error_count:
+        parts.append(f"{error_count} error{'s' if error_count != 1 else ''}")
+    if warning_count:
+        parts.append(f"{warning_count} warning{'s' if warning_count != 1 else ''}")
+    if info_count:
+        parts.append(f"{info_count} info")
+    a(" | ".join(parts))
+    a("")
+    a("---\n")
+
+    # Per-mixin sections
+    _SEVERITY_ICON = {"error": "\u274c", "warning": "\u26a0\ufe0f", "info": "\u2139\ufe0f"}
+    _CONF_ICON = {ConfidenceLevel.LOW: "\u274c", ConfidenceLevel.MEDIUM: "\u26a0\ufe0f", ConfidenceLevel.HIGH: "\u2705"}
+
+    for entry in unique_entries:
+        conf = confidence_map[entry.mixin_stem]
+        icon = _CONF_ICON.get(conf, "\u2753")
+
+        a(f"### {icon} {entry.mixin_stem} \u2014 {conf.value} confidence\n")
+
+        if not entry.warnings:
+            a("No manual changes needed.\n")
+            continue
 
-        if entry.warnings:
-            w("| Issue | Action Required |")
-            w("|-------|----------------|")
-            for warning in entry.warnings:
-                w(f"| {warning.category}: {warning.message} | {warning.action_required} |")
-            w("")
-        else:
-            w("No warnings detected.\n")
+        for warning in entry.warnings:
+            sev_icon = _SEVERITY_ICON.get(warning.severity, "\u2753")
+            a(f"- [ ] **{warning.category}** ({warning.severity}): {warning.message}")
+            a(f"  \u2192 {warning.action_required}")
+        a("")
 
     return "\n".join(lines)

package/vue3_migration/transform/composable_patcher.py

@@ -8,7 +8,9 @@ from ..core.warning_collector import (
 )
 from ..models import MixinMembers
 from .this_rewriter import rewrite_this_refs, rewrite_this_dollar_refs
-from .lifecycle_converter import extract_hook_body
+from .lifecycle_converter import (
+    extract_hook_body, convert_lifecycle_hooks, get_required_imports, HOOK_MAP,
+)
 
 
 def _add_vue_import(content: str, name: str) -> str:
@@ -314,12 +316,31 @@ def generate_member_declaration(
     return f"{indent}// {name} — could not classify, migrate manually"
 
 
+def _missing_hooks(composable_src: str, hooks: list[str]) -> list[str]:
+    """Return lifecycle hooks not yet present in the composable source.
+
+    For wrapped hooks (onMounted etc.), checks for ``fnName(`` to detect calls.
+    Inline hooks (beforeCreate/created) are always considered missing since
+    there's no reliable wrapper to detect.
+    """
+    missing: list[str] = []
+    for hook in hooks:
+        vue3_fn = HOOK_MAP.get(hook)
+        if vue3_fn is None:
+            # beforeCreate/created — inline, always treat as missing
+            missing.append(hook)
+        elif f"{vue3_fn}(" not in composable_src:
+            missing.append(hook)
+    return missing
+
+
 def patch_composable(
     composable_content: str,
     mixin_content: str,
     not_returned: list[str],
     missing: list[str],
     mixin_members: MixinMembers,
+    lifecycle_hooks: list[str] | None = None,
     indent: str = "  ",
 ) -> str:
     """Orchestrate composable patching for both blocked cases.
@@ -329,6 +350,8 @@ def patch_composable(
     Step 1 (not_returned): Add keys to the return statement.
     Step 2 (missing): Generate declarations and insert before return,
                       then add the names to the return statement.
+    Step 3 (lifecycle_hooks): Convert and insert lifecycle hooks that the
+                              composable doesn't already contain.
 
     Returns modified composable content (unchanged if reactive() guard triggered).
     """
@@ -359,13 +382,26 @@ def patch_composable(
         content = add_members_to_composable(content, declarations)
         content = add_keys_to_return(content, missing)
 
+    # Step 3: add lifecycle hooks not yet present in the composable
+    if lifecycle_hooks:
+        hooks_to_add = _missing_hooks(content, lifecycle_hooks)
+        if hooks_to_add:
+            inline_lines, wrapped_lines = convert_lifecycle_hooks(
+                mixin_content, hooks_to_add, ref_members, plain_members, indent,
+            )
+            hook_lines = inline_lines + wrapped_lines
+            if hook_lines:
+                content = add_members_to_composable(content, hook_lines)
+            for imp in get_required_imports(hooks_to_add):
+                content = _add_vue_import(content, imp)
+
     # Apply this.$ auto-rewrites ($nextTick, $set, $delete)
     content, dollar_imports = rewrite_this_dollar_refs(content)
     for imp in dollar_imports:
         content = _add_vue_import(content, imp)
 
     # Collect warnings and inject inline comments + confidence header
-    warnings = collect_mixin_warnings(mixin_content, mixin_members, [])
+    warnings = collect_mixin_warnings(mixin_content, mixin_members, lifecycle_hooks or [])
     confidence = compute_confidence(content, warnings)
     content = inject_inline_warnings(content, warnings, confidence, len(warnings))
 

package/vue3_migration/workflows/auto_migrate_workflow.py

@@ -16,25 +16,22 @@ from ..core.composable_search import find_composable_dirs, search_for_composable
 from ..core.file_resolver import compute_import_path, resolve_import_path
 from ..core.mixin_analyzer import (
     extract_lifecycle_hooks, extract_mixin_members,
-    find_external_this_refs, resolve_external_dep_sources,
+    find_external_this_refs,
 )
-from ..core.warning_collector import collect_mixin_warnings
+from ..core.warning_collector import collect_mixin_warnings, detect_name_collisions
 from ..models import (
     ComposableCoverage, FileChange, MigrationConfig, MigrationPlan, MigrationStatus,
     MixinEntry, MixinMembers,
 )
 from ..transform.composable_generator import (
-    generate_composable_from_mixin,
-    mixin_stem_to_composable_name,
+    generate_composable_from_mixin, mixin_stem_to_composable_name,
 )
 from ..transform.composable_patcher import patch_composable
 from ..transform.injector import (
-    add_composable_import, add_vue_import, inject_setup,
+    add_composable_import, inject_setup,
     remove_import_line, remove_mixin_from_array,
 )
-from ..transform.lifecycle_converter import (
-    convert_lifecycle_hooks, find_lifecycle_referenced_members, get_required_imports,
-)
+from ..transform.lifecycle_converter import find_lifecycle_referenced_members
 
 
 def _analyze_mixin_silent(
@@ -155,12 +152,17 @@ def plan_composable_patches(
 
     for _comp_path, entries in entries_by_component:
         for entry in entries:
-            if entry.status not in (
-                MigrationStatus.BLOCKED_NOT_RETURNED,
-                MigrationStatus.BLOCKED_MISSING_MEMBERS,
-            ):
+            if not entry.composable:
                 continue
-            if not entry.composable or not entry.classification:
+            has_blocked = (
+                entry.status in (
+                    MigrationStatus.BLOCKED_NOT_RETURNED,
+                    MigrationStatus.BLOCKED_MISSING_MEMBERS,
+                )
+                and entry.classification
+            )
+            has_hooks = bool(entry.lifecycle_hooks)
+            if not has_blocked and not has_hooks:
                 continue
             comp_path = entry.composable.file_path
             if comp_path not in patch_map:
@@ -168,12 +170,18 @@ def plan_composable_patches(
                     "content": comp_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n'),
                     "not_returned": set(),
                     "missing": set(),
+                    "lifecycle_hooks": [],
                     "mixin_members": entry.members,
                     "mixin_content": entry.mixin_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n'),
                 }
             rec = patch_map[comp_path]
-            rec["not_returned"].update(entry.classification.truly_not_returned)
-            rec["missing"].update(entry.classification.truly_missing)
+            if has_blocked:
+                rec["not_returned"].update(entry.classification.truly_not_returned)
+                rec["missing"].update(entry.classification.truly_missing)
+            if has_hooks:
+                for h in entry.lifecycle_hooks:
+                    if h not in rec["lifecycle_hooks"]:
+                        rec["lifecycle_hooks"].append(h)
 
     changes = []
     for comp_path, rec in patch_map.items():
@@ -184,12 +192,15 @@ def plan_composable_patches(
             not_returned=list(rec["not_returned"]),
             missing=list(rec["missing"]),
             mixin_members=rec["mixin_members"],
+            lifecycle_hooks=rec["lifecycle_hooks"] or None,
         )
         change_descs = []
         if rec["not_returned"]:
             change_descs.append(f"Added to return: {', '.join(sorted(rec['not_returned']))}")
         if rec["missing"]:
             change_descs.append(f"Added declarations: {', '.join(sorted(rec['missing']))}")
+        if rec["lifecycle_hooks"]:
+            change_descs.append(f"Added lifecycle hooks: {', '.join(rec['lifecycle_hooks'])}")
         changes.append(FileChange(
             file_path=comp_path,
             original_content=original,
@@ -247,92 +258,16 @@ def plan_new_composables(
     return changes
 
 
-def _inject_setup_external_dep_warnings(
-    lines: list[str],
-    entry: "MixinEntry",
-    all_entries: list["MixinEntry"],
-    own_members: set[str],
-    component_name: str,
-    indent: str,
-    component_members_by_section: dict[str, list[str]] | None = None,
-) -> list[str]:
-    """Scan lifecycle lines for remaining ``this.X`` and prepend source-resolved warnings.
-
-    Only processes non-``$`` references that survived ``rewrite_this_refs``
-    (i.e. external deps not defined in the current mixin).
-    """
-    if not lines:
-        return lines
-
-    all_text = "\n".join(lines)
-    external_names: list[str] = []
-    for m in re.finditer(r"\bthis\.(\w+)", all_text):
-        name = m.group(1)
-        if not name.startswith("$") and name not in external_names:
-            external_names.append(name)
-
-    if not external_names:
-        return lines
-
-    siblings = [e for e in all_entries if e is not entry]
-    sources = resolve_external_dep_sources(
-        external_names, siblings, own_members, component_name,
-        component_members_by_section=component_members_by_section,
-    )
-
-    result: list[str] = []
-    warned: set[str] = set()
-    for line in lines:
-        for m in re.finditer(r"\bthis\.(\w+)", line):
-            name = m.group(1)
-            if name.startswith("$") or name in warned:
-                continue
-            warned.add(name)
-            src = sources.get(name, {"kind": "unknown", "detail": None, "sources": []})
-            result.extend(
-                _format_setup_warning(name, src, entry, indent)
-            )
-        result.append(line)
-    return result
-
-
-def _format_setup_warning(
-    name: str, src: dict, entry: "MixinEntry", indent: str
-) -> list[str]:
-    """Format a source-resolved warning comment for a setup() external dep."""
-    if src["kind"] == "sibling":
-        detail = src["detail"]  # e.g. "loadingMixin.data"
-        sibling_stem = detail.split(".")[0]
-        sibling_composable = mixin_stem_to_composable_name(sibling_stem)
-        return [
-            f"{indent}// ⚠ MIGRATION: '{name}' — external dep (source: {detail} → {sibling_composable}).",
-            f"{indent}// this.{name} is unavailable in setup(). Use return value from {sibling_composable}() instead.",
-        ]
-    elif src["kind"] == "component":
-        detail = src["detail"]
-        return [
-            f"{indent}// ⚠ MIGRATION: '{name}' — external dep (source: {detail}).",
-            f"{indent}// this.{name} is unavailable in setup(). Replace with local ref.",
-        ]
-    elif src["kind"] == "ambiguous":
-        sources_str = ", ".join(src["sources"])
-        return [
-            f"{indent}// ⚠ MIGRATION: '{name}' — external dep (sources: {sources_str}).",
-            f"{indent}// Ambiguous origin — verify correct source before replacing this.{name}.",
-        ]
-    else:
-        return [
-            f"{indent}// ⚠ MIGRATION: '{name}' — external dep, source not found in component or sibling mixins.",
-            f"{indent}// May come from props, inject, or a parent component. Replace this.{name} manually.",
-        ]
-
-
 def plan_component_injections(
     entries_by_component: list[tuple[Path, list[MixinEntry]]],
     composable_patches: list[FileChange],
     config: MigrationConfig,
 ) -> list[FileChange]:
-    """Plan all component setup() injections, including lifecycle hook conversion.
+    """Plan all component setup() injections.
+
+    Lifecycle hooks live in the composable (generated or patched), never in
+    setup(). Members referenced in lifecycle hook bodies are included in the
+    composable destructure so the hooks can access them.
 
     Re-classifies entries whose composables were patched to account for
     the updated return_keys and identifiers.
@@ -355,7 +290,6 @@ def plan_component_injections(
         # R-7: normalize CRLF
         comp_source = comp_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n')
         own_members = extract_own_members(comp_source)
-        comp_members_by_section = extract_mixin_members(comp_source)
         ready_entries = []
 
         for entry in entries:
@@ -402,6 +336,20 @@ def plan_component_injections(
         if not ready_entries:
             continue
 
+        # Detect member name collisions across composables for this component
+        if len(ready_entries) > 1:
+            composable_members_map = {}
+            for entry in ready_entries:
+                if entry.composable and entry.classification:
+                    composable_members_map[entry.composable.fn_name] = list(
+                        entry.classification.injectable
+                    )
+            collision_warnings = detect_name_collisions(composable_members_map)
+            if collision_warnings:
+                for w in collision_warnings:
+                    w.mixin_stem = "cross-composable"
+                ready_entries[0].warnings.extend(collision_warnings)
+
         content = comp_source
         changes_desc = []
 
@@ -424,14 +372,13 @@ def plan_component_injections(
                 content = new
 
         composable_calls = []
-        all_inline_lines: list[str] = []
-        all_lifecycle_calls: list[str] = []
 
         for entry in ready_entries:
             injectable = list(entry.classification.injectable if entry.classification else entry.used_members)
-            mixin_content = None
 
-            # Augment injectable with members referenced in lifecycle hook bodies
+            # Augment injectable with members referenced in lifecycle hook bodies —
+            # the composable contains the hooks and needs these members destructured.
+            lifecycle_members: list[str] = []
             if entry.lifecycle_hooks and entry.composable:
                 mixin_content = entry.mixin_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n')
                 lifecycle_members = find_lifecycle_referenced_members(
@@ -455,41 +402,11 @@ def plan_component_injections(
             if injectable and entry.composable:
                 composable_calls.append((entry.composable.fn_name, injectable))
 
-            if entry.lifecycle_hooks:
-                if mixin_content is None:
-                    mixin_content = entry.mixin_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n')
-                ref_m = entry.members.data + entry.members.computed + entry.members.watch
-                plain_m = entry.members.methods
-                inline, wrapped = convert_lifecycle_hooks(
-                    mixin_content, entry.lifecycle_hooks, ref_m, plain_m,
-                    config.indent + config.indent,  # double indent to match setup() body level
-                )
-
-                # Inject source-resolved warnings for external deps in lifecycle code
-                comp_name = comp_path.stem
-                setup_indent = config.indent + config.indent
-                inline = _inject_setup_external_dep_warnings(
-                    inline, entry, entries, own_members, comp_name, setup_indent,
-                    component_members_by_section=comp_members_by_section,
-                )
-                wrapped = _inject_setup_external_dep_warnings(
-                    wrapped, entry, entries, own_members, comp_name, setup_indent,
-                    component_members_by_section=comp_members_by_section,
-                )
-
-                all_inline_lines.extend(inline)
-                all_lifecycle_calls.extend(wrapped)
-
-                for hook_import in get_required_imports(entry.lifecycle_hooks):
-                    content = add_vue_import(content, hook_import)
-
-        if composable_calls or all_inline_lines or all_lifecycle_calls:
+        if composable_calls:
             new = inject_setup(
                 content,
                 composable_calls,
                 config.indent,
-                lifecycle_calls=all_lifecycle_calls or None,
-                inline_setup_lines=all_inline_lines or None,
             )
             if new != content:
                 fn_names = [c[0] for c in composable_calls]
@@ -530,6 +447,7 @@ def run(project_root: Path, config: MigrationConfig) -> MigrationPlan:
     return MigrationPlan(
         component_changes=component_changes,
         composable_changes=composable_changes,
+        entries_by_component=entries,
     )
 
 
@@ -543,6 +461,11 @@ def run_scoped(
 
     Exactly one of component_path or mixin_stem must be provided.
     No file I/O. Returns a MigrationPlan the CLI can show as a diff and write.
+
+    Note: When component_path is provided, composable patches only aggregate
+    requirements from that component's entries. Shared composables may receive
+    incomplete patches. Use mixin_stem scope or full-project run for complete
+    composable coverage.
     """
     if component_path is None and mixin_stem is None:
         raise ValueError("Provide either component_path or mixin_stem")
@@ -563,4 +486,5 @@ def run_scoped(
     return MigrationPlan(
         component_changes=component_changes,
         composable_changes=composable_changes,
+        entries_by_component=entries,
     )