vue3-migration 1.4.0 → 1.4.1

package/package.json

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

@@ -25,22 +25,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 +138,16 @@ 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
+        # Ensure the last existing member has a trailing comma
+        before_close = content[:close_pos]
+        temp = before_close.rstrip()
+        if temp and temp[-1] not in (',', '{'):
+            before_close = temp + ',' + before_close[len(temp):]
+            close_pos += 1
+
         # 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:]
+        return before_close + new_key_lines + content[close_pos:]
     else:
         # Single-line return: check if adding keys would make it too long
         # Extract existing keys from the return block content

package/vue3_migration/workflows/auto_migrate_workflow.py

@@ -454,11 +454,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 +516,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 +555,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,