vue3-migration 1.4.0 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue3-migration",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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/__init__.py

@@ -1,3 +1,3 @@
 """Vue Mixin Migration Tool — Automates Vue 2 mixin to Vue 3 composable migration."""
 
-__version__ = "1.4.0"
+__version__ = "1.4.1"

package/vue3_migration/cli.py

@@ -517,9 +517,10 @@ def main(argv: list[str] | None = None):
 
     parser = argparse.ArgumentParser(add_help=False)
     parser.add_argument("--root", default=None)
+    parser.add_argument("--regenerate", "-R", action="store_true", default=False)
     known, args = parser.parse_known_args(args)
     project_root = Path(known.root).resolve() if known.root else Path.cwd()
-    config = MigrationConfig(project_root=project_root)
+    config = MigrationConfig(project_root=project_root, regenerate=known.regenerate)
 
     if not args:
         interactive_menu(config)

package/vue3_migration/core/component_analyzer.py

@@ -49,7 +49,7 @@ def find_used_members(component_source: str, member_names: list[str]) -> list[st
     """
     sections = []
     for tag in ("script", "template"):
-        tag_match = re.search(rf"<{tag}[^>]*>(.*?)</{tag}>", component_source, re.DOTALL)
+        tag_match = re.search(rf"<{tag}[^>]*>(.*)</{tag}>", component_source, re.DOTALL)
         if tag_match:
             sections.append(tag_match.group(1))
     search_text = "\n".join(sections) if sections else component_source
@@ -114,8 +114,10 @@ def extract_own_members(component_source: str) -> set[str]:
             brace_pos = ret.start() + ret.group().index("{")
             own_members.update(extract_property_names(extract_brace_block(body, brace_pos)))
 
-    # computed, methods, watch sections
-    for section in ("computed", "methods", "watch"):
+    # computed, methods sections (NOT watch — watch keys observe properties,
+    # they don't define/override them; a component watching a mixin property
+    # still needs the composable to provide that property)
+    for section in ("computed", "methods"):
         match = re.search(rf"\b{section}\s*:\s*\{{", source)
         if match:
             own_members.update(

package/vue3_migration/models.py

@@ -204,3 +204,4 @@ class MigrationConfig:
     dry_run: bool = False
     auto_confirm: bool = False
     indent: str = "  "
+    regenerate: bool = False

package/vue3_migration/transform/composable_generator.py

@@ -56,15 +56,19 @@ def _extract_func_body(section_body: str, name: str) -> str | None:
 
 def _extract_func_params(section_body: str, name: str) -> str:
     """Extract the parameter list of a named function inside a section body."""
-    # Standard: name(params)
-    m = re.search(rf'\b{re.escape(name)}\s*\(([^)]*)\)', section_body)
+    # Standard shorthand: name(params) {
+    m = re.search(rf'\b{re.escape(name)}\s*\(([^)]*)\)\s*\{{', section_body)
     if m:
         return m.group(1)
-    # name: function(params)
-    m = re.search(rf'\b{re.escape(name)}\s*:\s*function\s*\(([^)]*)\)', section_body)
+    # name: function(params) {
+    m = re.search(rf'\b{re.escape(name)}\s*:\s*function\s*\(([^)]*)\)\s*\{{', section_body)
     if m:
         return m.group(1)
-    # name: (params) =>
+    # name: (params) => {
+    m = re.search(rf'\b{re.escape(name)}\s*:\s*\(([^)]*)\)\s*=>\s*\{{', section_body)
+    if m:
+        return m.group(1)
+    # name: (params) => expr  (single-expression arrow without braces)
     m = re.search(rf'\b{re.escape(name)}\s*:\s*\(([^)]*)\)\s*=>', section_body)
     if m:
         return m.group(1)

package/vue3_migration/transform/composable_patcher.py

@@ -10,6 +10,7 @@ from ..models import MixinMembers
 from .this_rewriter import rewrite_this_refs, rewrite_this_dollar_refs
 from .lifecycle_converter import (
     extract_hook_body, convert_lifecycle_hooks, get_required_imports, HOOK_MAP,
+    find_lifecycle_referenced_members,
 )
 
 
@@ -25,22 +26,41 @@ def _remove_stale_comments(source: str) -> str:
 
     for line in lines:
         # Check for "NOT defined" or "NOT returned" comments
-        # Match patterns like: "count is NOT defined", "count NOT returned", "count is NOT returned"
-        not_match = re.search(r'//.*?\b(\w+)\s+(?:is\s+)?NOT\s+(?:defined|returned)', line)
+        # Match patterns like: "count is NOT defined", "count NOT returned",
+        # "count is NOT returned", "canDelete and hasRole are NOT defined"
+        not_match = re.search(r'//.*?\b(\w+)\s+(?:(?:is|are)\s+)?NOT\s+(?:defined|returned)', line)
         if not_match:
-            member_name = not_match.group(1)
-            # Skip non-identifiers that might be matched (e.g. "MIGRATION")
-            if member_name.upper() == member_name and len(member_name) > 2:
-                result_lines.append(line)
-                continue
-            # Check if the member IS actually defined or returned elsewhere in the source
-            is_defined = (
-                re.search(rf'\b(?:const|let|var|function)\s+{re.escape(member_name)}\b', source)
-                or re.search(rf'\breturn\s*\{{[^}}]*\b{re.escape(member_name)}\b', source)
-            )
-            if is_defined:
-                # Skip this stale comment line
-                continue
+            # Extract all lowercase-starting identifiers before "NOT" in the comment
+            comment_start = line.index('//')
+            comment_text = line[comment_start:]
+            not_word = re.search(r'\bNOT\b', comment_text)
+            not_pos = not_word.start() if not_word else comment_text.index('NOT')
+            before_not = comment_text[:not_pos]
+            noise = {'is', 'are', 'and', 'or', 'not', 'in', 'this', 'composable', 'the', 'from'}
+            identifiers = [m for m in re.findall(r'\b([a-z]\w*)\b', before_not) if m not in noise]
+
+            if identifiers:
+                # All mentioned identifiers must be defined for the comment to be stale
+                all_defined = all(
+                    re.search(rf'\b(?:const|let|var|function)\s+{re.escape(name)}\b', source)
+                    or re.search(rf'\breturn\s*\{{[^}}]*\b{re.escape(name)}\b', source, re.DOTALL)
+                    for name in identifiers
+                )
+                if all_defined:
+                    continue  # Remove stale comment
+            else:
+                # Fallback to single-member logic
+                member_name = not_match.group(1)
+                if member_name.upper() == member_name and len(member_name) > 2:
+                    result_lines.append(line)
+                    continue
+                is_defined = (
+                    re.search(rf'\b(?:const|let|var|function)\s+{re.escape(member_name)}\b', source)
+                    or re.search(rf'\breturn\s*\{{[^}}]*\b{re.escape(member_name)}\b', source, re.DOTALL)
+                )
+                if is_defined:
+                    continue
+
         result_lines.append(line)
 
     return '\n'.join(result_lines)
@@ -119,9 +139,22 @@ def add_keys_to_return(content: str, keys: list[str]) -> str:
             if stripped and not stripped.startswith('}'):
                 member_indent = line[:len(line) - len(stripped)]
                 break
-        # Insert new keys before the closing }
-        new_key_lines = "".join(f"{member_indent}{k},\n" for k in new_keys)
-        return content[:close_pos] + new_key_lines + content[close_pos:]
+
+        # Strip trailing whitespace before closing }, add comma if needed
+        before_close = content[:close_pos].rstrip()
+        if before_close and before_close[-1] not in (',', '{'):
+            before_close += ','
+
+        # Detect the closing brace's indentation from the original content
+        line_start_of_close = content.rfind('\n', 0, close_pos)
+        if line_start_of_close >= 0:
+            close_indent = content[line_start_of_close + 1:close_pos]
+        else:
+            close_indent = ''
+
+        # Insert new keys between last member and closing }
+        new_key_lines = "\n".join(f"{member_indent}{k}," for k in new_keys)
+        return before_close + "\n" + new_key_lines + "\n" + close_indent + content[close_pos:]
     else:
         # Single-line return: check if adding keys would make it too long
         # Extract existing keys from the return block content
@@ -152,9 +185,10 @@ def add_members_to_composable(content: str, member_lines: list[str]) -> str:
     """
     # Normalize CRLF (R-7)
     content = content.replace('\r\n', '\n').replace('\r', '\n')
-    m = re.search(r'\n([ \t]*)\breturn\s*\{', content)
-    if not m:
+    matches = list(re.finditer(r'\n([ \t]*)\breturn\s*\{', content))
+    if not matches:
         return content
+    m = matches[-1]
     existing_ids = set(extract_all_identifiers(content))
     lines_to_add = []
     for line in member_lines:
@@ -512,6 +546,35 @@ def patch_composable(
     if lifecycle_hooks:
         hooks_to_add = _missing_hooks(content, lifecycle_hooks)
         if hooks_to_add:
+            # Step 3a: Find mixin members referenced inside lifecycle hook bodies
+            # that are not yet in the composable (e.g. _handleEscapeKey).
+            all_member_names = (
+                mixin_members.data + mixin_members.computed
+                + mixin_members.methods + mixin_members.watch
+            )
+            lifecycle_deps = find_lifecycle_referenced_members(
+                mixin_content, hooks_to_add, all_member_names,
+            )
+            existing_ids = set(extract_all_identifiers(content))
+            missing_deps = [m for m in lifecycle_deps if m not in existing_ids]
+            if missing_deps:
+                dep_decls = [
+                    generate_member_declaration(
+                        name, mixin_content, mixin_members,
+                        ref_members, plain_members, indent,
+                    )
+                    for name in missing_deps
+                ]
+                content = add_members_to_composable(content, dep_decls)
+                content = add_keys_to_return(content, missing_deps)
+                if any("watch(" in d for d in dep_decls):
+                    content = _add_vue_import(content, "watch")
+                if any("ref(" in d for d in dep_decls):
+                    content = _add_vue_import(content, "ref")
+                if any("computed(" in d for d in dep_decls):
+                    content = _add_vue_import(content, "computed")
+
+            # Step 3b: Convert and insert lifecycle hooks
             inline_lines, wrapped_lines = convert_lifecycle_hooks(
                 mixin_content, hooks_to_add, ref_members, plain_members, indent,
             )

package/vue3_migration/workflows/auto_migrate_workflow.py

@@ -378,27 +378,11 @@ def plan_component_injections(
                             severity="warning",
                         ))
 
-        content = comp_source
-        changes_desc = []
-
-        for entry in ready_entries:
-            new = remove_import_line(content, entry.mixin_stem)
-            if new != content:
-                changes_desc.append(f"Removed import {entry.mixin_stem}")
-                content = new
-            injectable = entry.classification.injectable if entry.classification else entry.used_members
-            if injectable and entry.composable:
-                new = add_composable_import(content, entry.composable.fn_name, entry.composable.import_path)
-                if new != content:
-                    changes_desc.append(f"Added import {{{entry.composable.fn_name}}}")
-                    content = new
-
-        for entry in ready_entries:
-            new = remove_mixin_from_array(content, entry.local_name)
-            if new != content:
-                changes_desc.append(f"Removed {entry.local_name} from mixins")
-                content = new
-
+        # Pre-compute which entries will produce a composable call.
+        # Only migratable entries (those with injectable members) get their
+        # mixin removed.  Entries that won't produce a composable call are
+        # skipped and flagged for manual review.
+        migratable_entries = []
         composable_calls = []
 
         for entry in ready_entries:
@@ -420,15 +404,114 @@ def plan_component_injections(
             # precedence over setup() returns, so injecting them is redundant.
             # Keep lifecycle-referenced members even if overridden, since the
             # composable's lifecycle wrapper closure may depend on them.
+            overridden_in_injectable: list[str] = []
             if injectable and entry.composable:
                 lifecycle_members_set = set(lifecycle_members) if entry.lifecycle_hooks else set()
+                overridden_in_injectable = [
+                    m for m in injectable
+                    if m in own_members and m not in lifecycle_members_set
+                ]
                 injectable = [
                     m for m in injectable
                     if m not in own_members or m in lifecycle_members_set
                 ]
 
             if injectable and entry.composable:
+                migratable_entries.append(entry)
                 composable_calls.append((entry.composable.fn_name, injectable))
+                # Warn about overridden members that won't be destructured
+                if overridden_in_injectable:
+                    from ..models import MigrationWarning
+                    names = ", ".join(overridden_in_injectable)
+                    entry.warnings.append(MigrationWarning(
+                        mixin_stem=entry.mixin_stem,
+                        category="overridden-member",
+                        message=(
+                            f"Component overrides mixin member(s): {names}. "
+                            "These are NOT destructured from the composable."
+                        ),
+                        action_required=(
+                            f"Verify that the component's own {names} "
+                            "implementation does not depend on other mixin members."
+                        ),
+                        line_hint=None,
+                        severity="info",
+                    ))
+            else:
+                # Entry won't produce a composable call — keep the mixin.
+                from ..models import MigrationWarning
+                if not entry.used_members:
+                    if entry.lifecycle_hooks:
+                        hooks_str = ", ".join(entry.lifecycle_hooks)
+                        entry.warnings.append(MigrationWarning(
+                            mixin_stem=entry.mixin_stem,
+                            category="skipped-lifecycle-only",
+                            message=(
+                                f"Mixin '{entry.mixin_stem}' was NOT migrated: "
+                                f"it provides lifecycle hooks ({hooks_str}) but "
+                                "no members are directly referenced by the component."
+                            ),
+                            action_required=(
+                                "Manually convert lifecycle hooks to the composable, "
+                                "or remove the mixin if unused."
+                            ),
+                            line_hint=None,
+                            severity="warning",
+                        ))
+                    else:
+                        entry.warnings.append(MigrationWarning(
+                            mixin_stem=entry.mixin_stem,
+                            category="skipped-no-usage",
+                            message=(
+                                f"Mixin '{entry.mixin_stem}' was NOT migrated: "
+                                "no members are referenced by the component."
+                            ),
+                            action_required=(
+                                "Remove the mixin if unused, or manually convert "
+                                "if it provides side-effect functionality."
+                            ),
+                            line_hint=None,
+                            severity="warning",
+                        ))
+                else:
+                    overridden_names = ", ".join(
+                        entry.classification.overridden + entry.classification.overridden_not_returned
+                    ) if entry.classification else ""
+                    entry.warnings.append(MigrationWarning(
+                        mixin_stem=entry.mixin_stem,
+                        category="skipped-all-overridden",
+                        message=(
+                            f"Mixin '{entry.mixin_stem}' was NOT migrated: "
+                            f"all used members ({overridden_names}) are overridden "
+                            "by the component."
+                        ),
+                        action_required=(
+                            "Remove the mixin if the component's overrides are "
+                            "self-contained, or keep it if they depend on mixin internals."
+                        ),
+                        line_hint=None,
+                        severity="info",
+                    ))
+
+        content = comp_source
+        changes_desc = []
+
+        for entry in migratable_entries:
+            new = remove_import_line(content, entry.mixin_stem)
+            if new != content:
+                changes_desc.append(f"Removed import {entry.mixin_stem}")
+                content = new
+            if entry.composable:
+                new = add_composable_import(content, entry.composable.fn_name, entry.composable.import_path)
+                if new != content:
+                    changes_desc.append(f"Added import {{{entry.composable.fn_name}}}")
+                    content = new
+
+        for entry in migratable_entries:
+            new = remove_mixin_from_array(content, entry.local_name)
+            if new != content:
+                changes_desc.append(f"Removed {entry.local_name} from mixins")
+                content = new
 
         if composable_calls:
             new = inject_setup(
@@ -454,11 +537,57 @@ def plan_component_injections(
     return component_changes
 
 
+def plan_regenerated_composables(
+    entries_by_component: list[tuple[Path, list[MixinEntry]]],
+    project_root: Path,
+) -> list[FileChange]:
+    """Regenerate existing composables from their mixin source.
+
+    For each mixin that HAS an existing composable on disk, generates
+    fresh content using the generator instead of just patching.
+    """
+    seen_stems: set[str] = set()
+    changes = []
+
+    for _comp_path, entries in entries_by_component:
+        for entry in entries:
+            if entry.mixin_stem in seen_stems:
+                continue
+            # Only regenerate if composable already exists (not BLOCKED_NO_COMPOSABLE)
+            if entry.status == MigrationStatus.BLOCKED_NO_COMPOSABLE:
+                continue
+            if not entry.composable:
+                continue
+            seen_stems.add(entry.mixin_stem)
+
+            mixin_source = entry.mixin_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n')
+            content = generate_composable_from_mixin(
+                mixin_source=mixin_source,
+                mixin_stem=entry.mixin_stem,
+                mixin_members=entry.members,
+                lifecycle_hooks=entry.lifecycle_hooks,
+            )
+            original = entry.composable.file_path.read_text(errors="ignore").replace('\r\n', '\n').replace('\r', '\n')
+            if content != original:
+                changes.append(FileChange(
+                    file_path=entry.composable.file_path,
+                    original_content=original,
+                    new_content=content,
+                    changes=[f"Regenerated composable from {entry.mixin_stem}"],
+                ))
+    return changes
+
+
 def _build_all_composable_changes(
     entries: list[tuple[Path, list[MixinEntry]]],
     project_root: Path,
+    config: MigrationConfig | None = None,
 ) -> list[FileChange]:
     """Combine patched-existing + newly-generated composable changes."""
+    if config and config.regenerate:
+        regenerated = plan_regenerated_composables(entries, project_root)
+        generated = plan_new_composables(entries, project_root)
+        return regenerated + generated
     patched = plan_composable_patches(entries)
     generated = plan_new_composables(entries, project_root)
     return patched + generated
@@ -470,7 +599,7 @@ def run(project_root: Path, config: MigrationConfig) -> MigrationPlan:
     No file I/O. Returns a MigrationPlan the CLI can show as a diff and write.
     """
     entries = collect_all_mixin_entries(project_root, config)
-    composable_changes = _build_all_composable_changes(entries, project_root)
+    composable_changes = _build_all_composable_changes(entries, project_root, config)
     component_changes = plan_component_injections(entries, composable_changes, config)
     return MigrationPlan(
         component_changes=component_changes,
@@ -509,7 +638,7 @@ def run_scoped(
             if any(e.mixin_stem == mixin_stem for e in es)
         ]
 
-    composable_changes = _build_all_composable_changes(entries, project_root)
+    composable_changes = _build_all_composable_changes(entries, project_root, config)
     component_changes = plan_component_injections(entries, composable_changes, config)
     return MigrationPlan(
         component_changes=component_changes,