half-orm-dev 0.17.0a7__tar.gz → 0.17.0a10__tar.gz

{half_orm_dev-0.17.0a7/half_orm_dev.egg-info → half_orm_dev-0.17.0a10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.0a7
+Version: 0.17.0a10
 Summary: half_orm development Framework.
 Home-page: https://github.com/collorg/halfORM_dev
 Author: Joël Maïzi

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/cli/commands/check.py

@@ -97,7 +97,7 @@ def _display_check_results(result: dict, dry_run: bool, prune_branches: bool, ve
     # Show releases with candidates and staged patches
     releases_info = result.get('releases_info', {})
     if releases_info:
-        _display_releases_with_patches(releases_info, patch_branches, verbose)
+        _display_releases_with_patches(releases_info, patch_branches, release_branches, verbose)
     elif verbose:
         click.echo(f"\n📦 {utils.Color.bold('Active releases:')} None")
 
@@ -220,12 +220,13 @@ def _display_branch_info(branch_info: dict, verbose: bool, indent: str = "  ", s
     click.echo(f"{indent}{marker}• {display_name} - {status}")
 
 
-def _display_releases_with_patches(releases_info: dict, patch_branches: list, verbose: bool):
+def _display_releases_with_patches(releases_info: dict, patch_branches: list, release_branches: list, verbose: bool):
     """Display releases grouped by version with candidates and staged patches.
 
     Args:
         releases_info: Dict of {version: {candidates: [], staged: [], ...}}
         patch_branches: List of patch branch info dicts
+        release_branches: List of release branch info dicts
         verbose: Show verbose output
     """
     # Sort versions
@@ -236,9 +237,22 @@ def _display_releases_with_patches(releases_info: dict, patch_branches: list, ve
         candidates = info.get('candidates', [])
         staged = info.get('staged', [])
 
-        # Release header
-        total_patches = len(candidates) + len(staged)
-        click.echo(f"\n📦 {utils.Color.bold(f'Release {version}')} (ho-release/{version}):")
+        # Check if release branch exists
+        release_branch_name = f"ho-release/{version}"
+        release_branch_info = next((b for b in release_branches if b['name'] == release_branch_name), None)
+
+        # Release header with status
+        release_status = ""
+        if release_branch_info:
+            if not release_branch_info.get('exists_on_remote', False) and release_branch_info.get('exists_locally', False):
+                release_status = f" {utils.Color.yellow('⚠️ local only - remote deleted')}"
+            elif release_branch_info.get('sync_status') == 'remote_only':
+                release_status = f" {utils.Color.blue('☁️ on remote only')}"
+        else:
+            # Release files exist but no branch at all
+            release_status = f" {utils.Color.red('⚠️ branch not found')}"
+
+        click.echo(f"\n📦 {utils.Color.bold(f'Release {version}')} (ho-release/{version}):{release_status}")
 
         # Show staged patches
         if staged:
@@ -261,18 +275,22 @@ def _display_releases_with_patches(releases_info: dict, patch_branches: list, ve
 
                     if sync_status == 'synced':
                         status = utils.Color.green("✓ synced")
+                    elif sync_status == 'remote_only':
+                        status = utils.Color.blue("☁️ on remote only (run: git checkout -b ho-patch/" + patch_id + " origin/ho-patch/" + patch_id + ")")
                     elif sync_status == 'behind':
                         status = utils.Color.blue(f"⚠️ {behind} commits behind")
                     elif sync_status == 'ahead':
                         status = utils.Color.blue(f"↑ {ahead} ahead")
                     elif sync_status == 'diverged':
                         status = utils.Color.red(f"⚠ diverged (↑{ahead} ↓{behind})")
+                    elif sync_status == 'no_remote':
+                        status = utils.Color.yellow("⚠️ local only (remote deleted or not pushed - run: git branch -d " + branch_name + ")")
                     else:
                         status = "?"
 
                     click.echo(f"    • {patch_id} - {status}")
                 else:
-                    # Branch doesn't exist locally
+                    # Branch doesn't exist anywhere
                     click.echo(f"    • {patch_id} {utils.Color.red('⚠ branch not found')}")
 
         if not staged and not candidates:

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/cli/commands/patch.py

@@ -4,7 +4,7 @@ Patch command group - Unified patch development and management.
 Groups all patch-related commands under 'half_orm dev patch':
 - patch new: Create new patch branch and directory
 - patch apply: Apply current patch files to database
-- patch add: Add patch to stage release with validation
+- patch close: Add patch to stage release with validation
 
 Replaces legacy commands:
 - create-patch → patch new
@@ -33,7 +33,7 @@ def patch():
     Common workflow:
         1. half_orm dev patch new <patch_id>
         2. half_orm dev patch apply
-        3. half_orm dev patch add <patch_id>
+        3. half_orm dev patch close <patch_id>
     """
     pass
 
@@ -288,103 +288,3 @@ def patch_close(patch_id: str) -> None:
 
     except PatchManagerError as e:
         raise click.ClickException(str(e))
-
-
-@patch.command('add')
-@click.argument('patch_id', type=str)
-@click.option(
-    '--to-version', '-v',
-    type=str,
-    default=None,
-    help='Target release version (required if multiple stage releases exist)'
-)
-def patch_add(patch_id: str, to_version: Optional[str] = None) -> None:
-    """
-    Add patch to stage release file with validation.
-
-    Integrates developed patch into a stage release for deployment.
-    Must be run from ho-prod branch. All business logic is delegated
-    to ReleaseManager with distributed lock for safe concurrent operations.
-
-    \b
-    Complete workflow:
-        1. Acquire exclusive lock on ho-prod (via Git tag)
-        2. Create temporary validation branch
-        3. Apply all release patches + current patch
-        4. Run pytest validation tests
-        5. If tests pass: integrate to ho-prod
-        6. If tests fail: cleanup and exit with error
-        7. Send resync notifications to other patch branches
-        8. Archive patch branch to ho-release/{version}/ namespace
-        9. Cleanup patch branch
-        10. Release lock
-
-    \b
-    Args:
-        patch_id: Patch identifier to add (e.g., "456-user-auth")
-        to_version: Target release version (auto-detected if single stage exists)
-
-    \b
-    Branch Requirements:
-        - Must be on ho-prod branch
-        - Repository must be clean (no uncommitted changes)
-        - Must be synced with origin/ho-prod
-        - Patch branch ho-patch/PATCH_ID must exist
-        - At least one stage release file must exist
-
-    \b
-    Examples:
-        Add patch to auto-detected stage release:
-        $ half_orm dev patch add 456-user-auth
-
-        Add patch to specific version:
-        $ half_orm dev patch add 456-user-auth --to-version 1.3.6
-
-    \b
-    Output:
-        ✓ Detected stage release: 1.3.6-stage.txt
-        ✓ Validated patch 456-user-auth
-        ✓ All tests passed
-        ✓ Integrated to ho-prod
-        ✓ Archived branch: ho-release/1.3.6/456-user-auth
-        ✓ Notified 2 active patch branches
-
-        📝 Next steps:
-          1. Other developers: git pull && git rebase ho-prod
-          2. Continue development: half_orm dev patch new <next_patch_id>
-          3. Promote to RC: half_orm dev release promote rc
-
-    \b
-    Raises:
-        click.ClickException: If validation fails or integration errors occur
-    """
-    try:
-        # Get repository instance
-        repo = Repo()
-
-        # Display context
-        click.echo(f"Adding patch {utils.Color.bold(patch_id)} to stage release...")
-        click.echo()
-
-        # Delegate to ReleaseManager
-        result = repo.release_manager.add_patch_to_release(patch_id, to_version)
-
-        # Display success message
-        click.echo(f"✓ {utils.Color.green('Patch added to release successfully!')}")
-        click.echo()
-        click.echo(f"  Stage file:      {utils.Color.bold(result['stage_file'])}")
-        click.echo(f"  Patch added:     {utils.Color.bold(result['patch_id'])}")
-        click.echo(f"  Tests passed:    {utils.Color.green('✓')}")
-
-        if result.get('notified_branches'):
-            click.echo(f"  Notified:        {len(result['notified_branches'])} active branch(es)")
-
-        click.echo()
-        click.echo("📝 Next steps:")
-        click.echo(f"  • Other developers: {utils.Color.bold('git pull && git rebase ho-prod')}")
-        click.echo(f"  • Continue development: {utils.Color.bold('half_orm dev patch new <next_patch_id>')}")
-        click.echo(f"  • Promote to RC: {utils.Color.bold('half_orm dev release promote rc')}")
-        click.echo()
-
-    except ReleaseManagerError as e:
-        raise click.ClickException(str(e))

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/cli/commands/release.py

@@ -345,13 +345,12 @@ def release_hotfix(version: Optional[str] = None) -> None:
 
         # Display context
         if version:
-            click.echo(f"Reopening version {utils.Color.bold(version)} for hotfix...")
-        else:
-            click.echo("Reopening current production version for hotfix...")
+            click.echo(f"⚠️  Version parameter is ignored - will reopen current production version")
+        click.echo("Reopening current production version for hotfix...")
         click.echo()
 
-        # Delegate to ReleaseManager
-        result = repo.release_manager.reopen_for_hotfix(version)
+        # Delegate to ReleaseManager (auto-detects version)
+        result = repo.release_manager.reopen_for_hotfix()
 
         # Display success message
         click.echo(f"✓ {utils.Color.green('Version reopened for hotfix successfully!')}")

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/decorators.py

@@ -7,34 +7,39 @@ Provides common decorators for ReleaseManager and PatchManager.
 from functools import wraps
 
 
-def with_ho_prod_lock(branch: str = "ho-prod", timeout_minutes: int = 30):
+def with_dynamic_branch_lock(branch_getter, timeout_minutes: int = 30):
     """
-    Decorator to protect methods that modify ho-prod with a lock tag.
+    Decorator to protect methods with a dynamic branch lock.
 
-    The lock tag allows the pre-commit hook to permit commits on ho-prod
-    during the execution of the decorated method.
+    Unlike with_branch_lock which uses a static branch name, this decorator
+    calls a function to determine the branch name at runtime.
 
     Args:
-        branch: Branch to lock (default: "ho-prod")
+        branch_getter: Callable that takes (self, *args, **kwargs) and returns branch name
         timeout_minutes: Lock timeout in minutes (default: 30)
 
     Usage:
-        @with_ho_prod_lock()
-        def my_method(self, ...):
-            # Can commit to ho-prod here
+        def _get_release_branch(self, patch_id, *args, **kwargs):
+            # Logic to determine release branch from patch_id
+            return f"ho-release/{version}"
+
+        @with_dynamic_branch_lock(_get_release_branch)
+        def close_patch(self, patch_id):
+            # Will lock the release branch determined by _get_release_branch
             ...
 
     Notes:
-        - The decorator assumes `self._repo.hgit` has `acquire_branch_lock()`
-          and `release_branch_lock()` methods
+        - branch_getter is called with the same arguments as the decorated function
         - The lock is ALWAYS released in the finally block, even on error
-        - If lock acquisition fails, the method is not executed
     """
     def decorator(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
             lock_tag = None
             try:
+                # Determine branch name dynamically
+                branch = branch_getter(self, *args, **kwargs)
+
                 # Acquire lock
                 lock_tag = self._repo.hgit.acquire_branch_lock(branch, timeout_minutes=timeout_minutes)
 

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/hgit.py

@@ -255,6 +255,32 @@ class HGit:
         "Proxy to git.commit method"
         return self.__git_repo.git.checkout(*args, **kwargs)
 
+    def checkout_paths_from_branch(self, branch: str, paths: list) -> None:
+        """
+        Checkout specific paths from another branch into working directory.
+
+        This allows selective extraction of files/directories from a branch
+        without merging the entire branch. Used to sync metadata files
+        (like releases/*.txt) between branches.
+
+        Args:
+            branch: Source branch name (e.g., "ho-release/0.1.0")
+            paths: List of paths to checkout (e.g., ["releases/", "docs/"])
+
+        Examples:
+            # Copy only releases/ directory from release branch to current branch
+            hgit.checkout("ho-prod")
+            hgit.checkout_paths_from_branch("ho-release/0.1.0", ["releases/"])
+            # Now releases/ contains files from ho-release/0.1.0
+            hgit.commit("-m", "sync releases/ from ho-release/0.1.0")
+
+        Notes:
+            - Changes are staged automatically
+            - Current branch must be checked out first
+            - Paths are relative to repository root
+        """
+        self.__git_repo.git.checkout(branch, '--', *paths)
+
     def pull(self, *args, **kwargs):
         "Proxy to git.pull method"
         return self.__git_repo.git.pull(*args, **kwargs)
@@ -411,12 +437,13 @@ class HGit:
 
     def fetch_from_origin(self) -> None:
         """
-        Fetch all references from origin remote.
+        Fetch all references from origin remote with pruning.
 
         Updates local knowledge of all remote references including:
         - All remote branches
         - All remote tags
         - Other remote refs
+        - Removes stale remote-tracking references (--prune)
 
         This is more comprehensive than fetch_tags() which only fetches tags.
         Used before patch creation to ensure up-to-date view of remote state.
@@ -427,10 +454,11 @@ class HGit:
         Examples:
             hgit.fetch_from_origin()
             # Local git now has complete up-to-date view of origin
+            # Stale remote refs (deleted branches on remote) are removed
         """
         try:
             origin = self.__git_repo.remote('origin')
-            origin.fetch()
+            origin.fetch(prune=True)
         except Exception as e:
             from git.exc import GitCommandError
             if isinstance(e, GitCommandError):
@@ -1447,11 +1475,19 @@ class HGit:
         remote_branches = self.get_remote_branches()
         remote_branch_names = {b.replace('origin/', '') for b in remote_branches}
 
-        # Get ho-patch branches
-        patch_branches = self.get_local_branches(pattern="ho-patch/*")
+        # Get ho-patch branches (local + remote)
+        local_patch_branches = self.get_local_branches(pattern="ho-patch/*")
+        remote_patch_branches = [b.replace('origin/', '') for b in remote_branches
+                                if b.startswith('origin/ho-patch/')]
+        # Combine local and remote, avoiding duplicates
+        all_patch_branches = list(set(local_patch_branches + remote_patch_branches))
 
-        # Get ho-release branches
-        release_branches = self.get_local_branches(pattern="ho-release/*")
+        # Get ho-release branches (local + remote)
+        local_release_branches = self.get_local_branches(pattern="ho-release/*")
+        remote_release_branches = [b.replace('origin/', '') for b in remote_branches
+                                  if b.startswith('origin/ho-release/')]
+        # Combine local and remote, avoiding duplicates
+        all_release_branches = list(set(local_release_branches + remote_release_branches))
 
         # Parse stage files to identify active release branches and their order
         active_release_patches = set()
@@ -1477,11 +1513,18 @@ class HGit:
                 except Exception:
                     pass
 
-        def get_branch_info(branch: str, check_stage: bool = False) -> dict:
-            """Helper to get branch status."""
+        def get_branch_info(branch: str, check_stage: bool = False, is_local: bool = True) -> dict:
+            """Helper to get branch status.
+
+            Args:
+                branch: Branch name
+                check_stage: Whether to check stage file membership
+                is_local: Whether branch exists locally
+            """
             info = {
                 'name': branch,
                 'is_current': branch == current_branch,
+                'exists_locally': is_local,
                 'exists_on_remote': branch in remote_branch_names,
                 'sync_status': 'unknown',
                 'ahead': 0,
@@ -1508,9 +1551,13 @@ class HGit:
                     info['in_stage_file'] = False
                     info['order'] = 999
 
+            # Determine sync status
             if not info['exists_on_remote']:
                 info['sync_status'] = 'no_remote'
+            elif not info['exists_locally']:
+                info['sync_status'] = 'remote_only'
             else:
+                # Both local and remote exist - check sync
                 try:
                     is_synced, status = self.is_branch_synced(branch, remote='origin')
                     info['sync_status'] = status
@@ -1535,8 +1582,19 @@ class HGit:
 
             return info
 
+        # Build branch info with local/remote indication
+        patch_branch_infos = []
+        for branch in all_patch_branches:
+            is_local = branch in local_patch_branches
+            patch_branch_infos.append(get_branch_info(branch, is_local=is_local))
+
+        release_branch_infos = []
+        for branch in all_release_branches:
+            is_local = branch in local_release_branches
+            release_branch_infos.append(get_branch_info(branch, check_stage=True, is_local=is_local))
+
         return {
             'current_branch': current_branch,
-            'patch_branches': [get_branch_info(b) for b in patch_branches],
-            'release_branches': [get_branch_info(b, check_stage=True) for b in release_branches]
+            'patch_branches': patch_branch_infos,
+            'release_branches': release_branch_infos
         }

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/patch_manager.py

@@ -20,6 +20,7 @@ from git.exc import GitCommandError
 from half_orm import utils
 from half_orm_dev import modules
 from .patch_validator import PatchValidator, PatchInfo
+from .decorators import with_dynamic_branch_lock
 
 
 class PatchManagerError(Exception):
@@ -1227,6 +1228,7 @@ class PatchManager:
                 # Directory deletion may fail (permissions, etc.) - continue
                 pass
 
+    @with_dynamic_branch_lock(lambda self, patch_id, description=None: "ho-prod")
     def create_patch(self, patch_id: str, description: Optional[str] = None) -> dict:
         """
         Create new patch with atomic tag-first reservation strategy.
@@ -1286,7 +1288,8 @@ class PatchManager:
             # With description for README and commits
         """
         # Step 1-3: Validate context
-        release_version = self._validate_on_ho_release()  # NEW: returns version
+        release_branch = self._validate_on_ho_release()
+        release_version = release_branch.replace("ho-release/", "")
         self._validate_repo_clean()
         self._validate_has_remote()
 
@@ -1299,16 +1302,12 @@ class PatchManager:
         lock_tag = None
         # Save initial state for rollback
         initial_branch = self._repo.hgit.branch  # Should be ho-release/X.Y.Z
-        release_branch = f"ho-release/{release_version}"
         patch_dir = None
         commit_created = False
         tag_pushed = False
         modifications_started = False  # Track if we started making changes
         branch_name = f"ho-patch/{normalized_id}"
         try:
-            # Step 5: ACQUIRE LOCK on ho-release/X.Y.Z (with 30 min timeout for stale locks)
-            lock_tag = self._repo.hgit.acquire_branch_lock(release_branch, timeout_minutes=30)
-
             # Step 6: Fetch all references from remote (branches + tags) - with lock held
             self._fetch_from_remote()
 
@@ -1347,6 +1346,9 @@ class PatchManager:
             tag_pushed = True  # Tag pushed = point of no return
             # ✅ If we reach here: patch number globally reserved!
 
+            # Step 11b: Sync release files to ho-prod (non-critical)
+            self._sync_release_files_to_ho_prod(release_version, release_branch, critical=False)
+
             # === BRANCH CREATION (after reservation) ===
 
             # Step 11: Create branch FROM current commit (after tag push)
@@ -1363,13 +1365,7 @@ class PatchManager:
                 click.echo(f"⚠️  Push branch manually: git push -u origin {branch_name}")
                 # Don't raise - tag pushed means success
 
-            # Step 13: Checkout to new branch (non-critical, warn if fails)
-            try:
-                self._checkout_branch(branch_name)
-            except Exception as e:
-                import click
-                click.echo(f"⚠️  Checkout failed but patch created successfully")
-                click.echo(f"Run: git checkout {branch_name}")
+            # Note: No need to checkout - already on branch after _create_git_branch()
 
         except Exception as e:
             # Only rollback if tag NOT pushed yet AND modifications started
@@ -1385,10 +1381,6 @@ class PatchManager:
                 )
             raise PatchManagerError(f"Patch creation failed: {e}")
 
-        finally:
-            # ALWAYS release lock (even on error)
-            self._repo.hgit.release_branch_lock(lock_tag)
-
         # Return result
         return {
             'patch_id': normalized_id,
@@ -1398,6 +1390,80 @@ class PatchManager:
             'version': release_version  # NEW: include release version
         }
 
+    def _sync_release_files_to_ho_prod(self, version: str, release_branch: str, critical: bool = False) -> None:
+        """
+        Sync release files for a specific version to ho-prod.
+
+        This ensures that ho-prod always has the latest state of release metadata
+        files, making it the single source of truth for release information.
+
+        Args:
+            version: Release version (e.g., "0.17.0")
+            release_branch: Source release branch (e.g., "ho-release/0.17.0")
+            critical: If True, raise exception on failure. If False, just warn.
+
+        Raises:
+            PatchManagerError: If critical=True and sync fails
+
+        Examples:
+            # After modifying candidates.txt on ho-release/0.17.0
+            self._sync_release_files_to_ho_prod("0.17.0", "ho-release/0.17.0")
+        """
+        try:
+            # Save current branch
+            current_branch = release_branch
+
+            # Checkout ho-prod
+            self._repo.hgit.checkout("ho-prod")
+
+            # Copy ALL files for this specific version from release branch
+            # This includes: -candidates.txt, -stage.txt, -rc*.txt, .txt, -hotfix*.txt
+            # Using wildcard pattern to get all files matching the version
+            self._repo.hgit.checkout_paths_from_branch(release_branch, [f"releases/{version}*.txt"])
+
+            # Commit on ho-prod
+            self._repo.hgit.commit("-m", f"[HOP] sync release {version} files from {release_branch}")
+            self._repo.hgit.push_branch("ho-prod")
+
+            # Return to release branch
+            self._repo.hgit.checkout(current_branch)
+        except Exception as e:
+            # Try to return to release branch even on error
+            try:
+                self._repo.hgit.checkout(release_branch)
+            except:
+                pass
+
+            if critical:
+                raise PatchManagerError(f"Failed to sync release files to ho-prod: {e}")
+            else:
+                # Non-critical - just warn
+                import click
+                click.echo(f"⚠️  Warning: Failed to sync release files to ho-prod: {e}")
+                click.echo(f"⚠️  You may need to manually sync releases/ to ho-prod")
+
+    def _get_release_branch_for_patch(self, patch_id: str, *args, **kwargs) -> str:
+        """
+        Helper to determine release branch for close_patch lock.
+
+        Args:
+            patch_id: Patch identifier
+
+        Returns:
+            Release branch name (e.g., "ho-release/0.17.0")
+
+        Raises:
+            PatchManagerError: If patch not found in candidates
+        """
+        version = self._find_version_for_candidate(patch_id)
+        if not version:
+            raise PatchManagerError(
+                f"Patch {patch_id} not found in any candidates file.\n"
+                f"Available candidates:\n{self._list_all_candidates()}"
+            )
+        return f"ho-release/{version}"
+
+    @with_dynamic_branch_lock(lambda self, patch_id: "ho-prod")
     def close_patch(self, patch_id: str) -> dict:
         """
         Close a patch by merging it into the release branch.
@@ -1463,7 +1529,7 @@ class PatchManager:
 
         # 5. Merge patch branch into release branch
         try:
-            self._repo.hgit.merge(patch_branch, message=f"[HOP] Merge #{patch_id} into %{version}")
+            self._repo.hgit.merge(patch_branch, message=f'''[HOP] Merge #{patch_id} into %"{version}"''')
         except Exception as e:
             raise PatchManagerError(
                 f"Failed to merge {patch_branch} into {release_branch}: {e}\n"
@@ -1473,13 +1539,16 @@ class PatchManager:
         # 6. Move from candidates to stage
         self._move_patch_to_stage(patch_id, version)
 
-        # 7. Commit changes
+        # 7. Commit changes on release branch
         try:
             self._repo.hgit.commit("-m", f"[HOP] move patch #{patch_id} from candidate to stage %{version}")
             self._repo.hgit.push_branch(release_branch)
         except Exception as e:
             raise PatchManagerError(f"Failed to commit/push changes: {e}")
 
+        # 7b. Sync release files to ho-prod (metadata only, not code)
+        self._sync_release_files_to_ho_prod(version, release_branch, critical=True)
+
         # 8. Delete patch branch (local and remote)
         try:
             self._repo.hgit.delete_local_branch(patch_branch)
@@ -1638,14 +1707,14 @@ class PatchManager:
         to allow patches to see each other's changes and support dependencies.
 
         Returns:
-            Version string extracted from branch name (e.g., "0.17.0")
+            branch name (e.g., "ho-release/0.17.0")
 
         Raises:
             PatchManagerError: If not on ho-release/* branch
 
         Examples:
-            version = self._validate_on_ho_release()
-            # On ho-release/0.17.0 → returns "0.17.0"
+            branch_name = self._validate_on_ho_release()
+            # On ho-release/X.Y.Z → returns "ho-release/X.Y.Z"
             # On main → raises PatchManagerError
         """
         current_branch = self._repo.hgit.branch
@@ -1656,9 +1725,7 @@ class PatchManager:
                 f"Hint: Run 'half_orm dev release new <level>' first to create a release"
             )
 
-        # Extract version from branch name (ho-release/X.Y.Z → X.Y.Z)
-        version = current_branch.replace("ho-release/", "")
-        return version
+        return current_branch
 
     def _validate_on_ho_prod(self) -> None:
         """

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/release_manager.py

@@ -16,7 +16,7 @@ from typing import Optional, Tuple, List, Dict
 from dataclasses import dataclass
 
 from git.exc import GitCommandError
-from half_orm_dev.decorators import with_ho_prod_lock
+from half_orm_dev.decorators import with_dynamic_branch_lock
 
 class ReleaseManagerError(Exception):
     """Base exception for ReleaseManager operations."""
@@ -2285,7 +2285,7 @@ class ReleaseManager:
         version_tags.sort(key=version_key, reverse=True)
         return version_tags[0]
 
-    @with_ho_prod_lock()
+    @with_dynamic_branch_lock(lambda self, level: "ho-prod")
     def new_release(self, level: str) -> dict:
         """
         Create a new release with integration branch.
@@ -2380,7 +2380,7 @@ class ReleaseManager:
             'stage_file': str(stage_file)
         }
 
-    @with_ho_prod_lock()
+    @with_dynamic_branch_lock(lambda self, patch_id, version: "ho-prod")
     def add_patch_to_release(self, patch_id: str, version: str) -> dict:
         """
         Add a patch to a release by merging into the release branch.
@@ -2526,8 +2526,8 @@ class ReleaseManager:
         stage_files.sort(key=version_key)
         return stage_files[0].stem.replace('-stage', '')
 
-    @with_ho_prod_lock()
-    def promote_to_rc(self, version: str = None) -> dict:
+    @with_dynamic_branch_lock(lambda self: "ho-prod")
+    def promote_to_rc(self) -> dict:
         """
         Promote a stage release to RC by tagging the release branch.
 
@@ -2548,7 +2548,7 @@ class ReleaseManager:
             ReleaseManagerError: If promotion fails
 
         Examples:
-            rel_mgr.promote_to_rc("0.1.0")
+            rel_mgr.promote_to_rc()
             # → Creates tag "0.1.0-rcN" on ho-release/0.1.0
             # → Renames 0.1.0-stage.txt to 0.1.0-rcN.txt
 
@@ -2556,8 +2556,7 @@ class ReleaseManager:
             # → Promotes the smallest stage release
         """
         # Auto-detect version if not provided
-        if version is None:
-            version = self._detect_version_to_promote('rc')
+        version = self._detect_version_to_promote('rc')
 
         stage_file = self._releases_dir / f"{version}-stage.txt"
         if not stage_file.exists():
@@ -2597,6 +2596,13 @@ class ReleaseManager:
             self._repo.hgit.commit("-m", f"[HOP] Promote release %{version} to RC {rc_number}")
             self._repo.hgit.push_branch(release_branch)
 
+            # Sync RC and stage files to ho-prod (single source of truth)
+            self._repo.patch_manager._sync_release_files_to_ho_prod(
+                version,
+                release_branch,
+                critical=False
+            )
+
             return {
                 'version': version,
                 'tag': rc_tag,
@@ -2606,8 +2612,8 @@ class ReleaseManager:
         except Exception as e:
             raise ReleaseManagerError(f"Failed to promote to RC: {e}")
 
-    @with_ho_prod_lock()
-    def promote_to_prod(self, version: str = None) -> dict:
+    @with_dynamic_branch_lock(lambda self: "ho-prod")
+    def promote_to_prod(self) -> dict:
         """
         Promote stage release to production.
 
@@ -2635,7 +2641,7 @@ class ReleaseManager:
             ReleaseManagerError: If promotion fails
 
         Examples:
-            rel_mgr.promote_to_prod("0.1.0")
+            rel_mgr.promote_to_prod()
             # → Merges ho-release/0.1.0 into ho-prod
             # → Creates tag "0.1.0"
             # → Deletes candidates.txt, renames stage.txt to 0.1.0.txt
@@ -2644,9 +2650,8 @@ class ReleaseManager:
             rel_mgr.promote_to_prod()  # Auto-detect version
             # → Promotes the smallest RC release
         """
-        # Auto-detect version if not provided
-        if version is None:
-            version = self._detect_version_to_promote('prod')
+        # Auto-detect version
+        version = self._detect_version_to_promote('prod')
 
         stage_file = self._releases_dir / f"{version}-stage.txt"
         if not stage_file.exists():
@@ -2702,10 +2707,31 @@ class ReleaseManager:
                         "ho-prod has been restored to its previous state."
                     )
 
-            # 3. Apply patches and generate schema
-            self._apply_release_patches(version)
+            # 3. Apply only NEW patches from stage (if any) and generate schema
+            # Note: RC patches have already been applied during promote_to_rc
+            stage_patches = self.read_release_patches(f"{version}-stage.txt")
+
+            if stage_patches:
+                # There are new patches after RC - apply them
+                # First, restore from latest RC schema
+                latest_rc = self._get_latest_rc_number(version)
+                rc_schema_version = f"{version}-rc{latest_rc}" if latest_rc > 0 else "0.0.0"
+
+                # Restore from RC schema if it exists, otherwise from baseline
+                try:
+                    self._repo.restore_database_from_schema(rc_schema_version)
+                except:
+                    self._repo.restore_database_from_schema()
+
+                # Apply new stage patches
+                for patch_id in stage_patches:
+                    self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
+            else:
+                # No new patches - just restore from latest RC
+                # The database should already be in the correct state from RC
+                pass
 
-            # Generate schema dump for this version
+            # Generate schema dump for this production version
             model_dir = Path(self._repo.base_dir) / "model"
             self._repo.database._generate_schema_sql(version, model_dir)
 
@@ -2761,6 +2787,39 @@ class ReleaseManager:
         except Exception as e:
             raise ReleaseManagerError(f"Failed to promote to production: {e}")
 
+    def _get_latest_rc_number(self, version: str) -> int:
+        """
+        Get the latest (highest) RC number for a version.
+
+        Args:
+            version: Version string (e.g., "1.3.5")
+
+        Returns:
+            Latest RC number (0 if no RCs exist, 1 for rc1, 2 for rc2, etc.)
+
+        Examples:
+            # No RCs
+            latest = mgr._get_latest_rc_number("1.3.5")
+            # → 0
+
+            # rc1, rc2 exist
+            latest = mgr._get_latest_rc_number("1.3.5")
+            # → 2
+        """
+        rc_files = self.get_rc_files(version)
+        if not rc_files:
+            return 0
+
+        # Extract RC numbers from filenames
+        rc_numbers = []
+        for rc_file in rc_files:
+            # Format: "1.3.5-rc2.txt" → extract "2"
+            match = re.search(r'-rc(\d+)\.txt$', rc_file.name)
+            if match:
+                rc_numbers.append(int(match.group(1)))
+
+        return max(rc_numbers) if rc_numbers else 0
+
     def _determine_rc_number(self, version: str) -> int:
         """
         Determine next RC number for version.
@@ -2812,8 +2871,8 @@ class ReleaseManager:
         # Fallback (shouldn't happen with valid RC files)
         return len(rc_files) + 1
 
-    @with_ho_prod_lock()
-    def reopen_for_hotfix(self, version: str = None) -> dict:
+    @with_dynamic_branch_lock(lambda self: "ho-prod")
+    def reopen_for_hotfix(self) -> dict:
         """
         Reopen a production version for hotfix development.
 
@@ -2855,10 +2914,8 @@ class ReleaseManager:
             8. Switch to branch
         """
         try:
-            # 1. Determine version to reopen
-            if version is None:
-                # Get current production version from model/schema.sql
-                version = self._get_production_version()
+            # Get current production version from model/schema.sql
+            version = self._get_production_version()
 
             # Validate version format
             if not re.match(r'^\d+\.\d+\.\d+$', version):
@@ -2936,6 +2993,7 @@ class ReleaseManager:
         except Exception as e:
             raise ReleaseManagerError(f"Failed to reopen version for hotfix: {e}")
 
+    @with_dynamic_branch_lock(lambda self: "ho-prod")
     def promote_to_hotfix(self) -> dict:
         """
         Promote hotfix release to production with hotfix tag.
@@ -2943,14 +3001,16 @@ class ReleaseManager:
         Similar to promote_to_prod() but:
         - Works from ho-release/X.Y.Z branch (not ho-prod)
         - Creates hotfix tag vX.Y.Z-hotfixN (not vX.Y.Z)
+        - Renames stage.txt to X.Y.Z-hotfixN.txt
         - Merges ho-release/X.Y.Z into ho-prod
-        - Keeps ho-release/X.Y.Z branch for potential additional hotfixes
+        - Deletes ho-release/X.Y.Z branch after promotion
 
         Returns:
             dict with:
                 - version: Base version (e.g., "1.3.5")
                 - hotfix_tag: Tag created (e.g., "v1.3.5-hotfix1")
                 - branch: Branch used (e.g., "ho-release/1.3.5")
+                - deleted_branches: List of deleted branches
 
         Raises:
             ReleaseManagerError: If validation fails or promotion errors occur
@@ -2960,9 +3020,12 @@ class ReleaseManager:
             2. Verify candidates.txt is empty
             3. Determine next hotfix number
             4. Merge ho-release/X.Y.Z into ho-prod
-            5. Generate SQL dumps on ho-prod
-            6. Create hotfix tag vX.Y.Z-hotfixN on ho-prod
-            7. Return to ho-release/X.Y.Z
+            5. Rename stage.txt to X.Y.Z-hotfixN.txt and delete candidates.txt
+            6. Apply release patches and generate SQL dumps on ho-prod
+            7. Commit release file changes
+            8. Create hotfix tag vX.Y.Z-hotfixN on ho-prod
+            9. Push ho-prod
+            10. Delete ho-release/X.Y.Z branch
         """
         try:
             # 1. Verify on ho-release/* branch
@@ -3009,19 +3072,37 @@ class ReleaseManager:
             merge_msg = f"[release] Merge hotfix %{version}-hotfix{hotfix_num}"
             self._repo.hgit.merge(current_branch, message=merge_msg)
 
-            # 5. Apply release patches and generate SQL dumps
+            # 5. Rename stage file to hotfix file and delete candidates
+            stage_file = self._releases_dir / f"{version}-stage.txt"
+            hotfix_file = self._releases_dir / f"{version}-hotfix{hotfix_num}.txt"
+            candidates_file = self._releases_dir / f"{version}-candidates.txt"
+
+            if stage_file.exists():
+                stage_file.rename(hotfix_file)
+                self._repo.hgit.add(str(stage_file))   # Old path (deleted)
+                self._repo.hgit.add(str(hotfix_file))   # New path (created)
+
+            # Delete candidates file if it exists
+            if candidates_file.exists():
+                candidates_file.unlink()
+                self._repo.hgit.add(str(candidates_file))  # Mark as deleted
+
+            # 6. Apply release patches and generate SQL dumps
             self._apply_release_patches(version, True)
 
-            # 6. Create hotfix tag on ho-prod
+            # 7. Commit release file changes
+            self._repo.hgit.commit("-m", f"[HOP] Finalize hotfix %{version}-hotfix{hotfix_num} release files")
+
+            # 8. Create hotfix tag on ho-prod
             self._repo.hgit.create_tag(hotfix_tag, f"Hotfix release %{version}-hotfix{hotfix_num}")
             self._repo.hgit.push_tag(hotfix_tag)
 
-            # 7. Push ho-prod
+            # 9. Push ho-prod
             self._repo.hgit.push_branch("ho-prod")
 
             deleted_branches = []
 
-            # 7. Delete release branch (force=True because Git may not recognize the merge)
+            # 10. Delete release branch (force=True because Git may not recognize the merge)
             try:
                 self._repo.hgit.delete_branch(current_branch, force=True)
                 self._repo.hgit.delete_remote_branch(current_branch)

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/repo.py

@@ -773,34 +773,59 @@ class Repo:
 
         # 2. Get active branches status and release files
         try:
-            # Find release files (candidates and stage)
+            # Find release files (candidates and stage) from ho-prod
             releases_info = {}
             if hasattr(self, 'release_manager'):
-                releases_dir = Path(self.__base_dir) / 'releases'
-                if releases_dir.exists():
-                    # Group files by version
-                    from collections import defaultdict
-                    by_version = defaultdict(dict)
-
-                    for candidates_file in releases_dir.glob('*-candidates.txt'):
-                        version = candidates_file.stem.replace('-candidates', '')
-                        by_version[version]['candidates_file'] = str(candidates_file)
-                        # Read candidates
-                        candidates_content = candidates_file.read_text(encoding='utf-8').strip()
-                        by_version[version]['candidates'] = [
-                            c.strip() for c in candidates_content.split('\n') if c.strip()
-                        ]
-
-                    for stage_file in releases_dir.glob('*-stage.txt'):
-                        version = stage_file.stem.replace('-stage', '')
-                        by_version[version]['stage_file'] = str(stage_file)
-                        # Read staged patches
-                        stage_content = stage_file.read_text(encoding='utf-8').strip()
-                        by_version[version]['staged'] = [
-                            s.strip() for s in stage_content.split('\n') if s.strip()
-                        ]
-
-                    releases_info = dict(by_version)
+                # Save current branch
+                try:
+                    current_branch = str(self.hgit._HGit__git_repo.active_branch)
+                except:
+                    current_branch = None
+
+                # Switch to ho-prod to read release files (source of truth)
+                try:
+                    self.hgit.checkout('ho-prod')
+
+                    # Pull latest changes from origin to ensure we have up-to-date metadata
+                    try:
+                        self.hgit.pull()
+                    except Exception:
+                        pass  # Best effort - may fail if no remote or no changes
+
+                    releases_dir = Path(self.__base_dir) / 'releases'
+                    if releases_dir.exists():
+                        # Group files by version
+                        from collections import defaultdict
+                        by_version = defaultdict(dict)
+
+                        for candidates_file in releases_dir.glob('*-candidates.txt'):
+                            version = candidates_file.stem.replace('-candidates', '')
+                            by_version[version]['candidates_file'] = str(candidates_file)
+                            # Read candidates (skip comments)
+                            candidates_content = candidates_file.read_text(encoding='utf-8').strip()
+                            by_version[version]['candidates'] = [
+                                c.strip() for c in candidates_content.split('\n')
+                                if c.strip() and not c.startswith('#')
+                            ]
+
+                        for stage_file in releases_dir.glob('*-stage.txt'):
+                            version = stage_file.stem.replace('-stage', '')
+                            by_version[version]['stage_file'] = str(stage_file)
+                            # Read staged patches (skip comments)
+                            stage_content = stage_file.read_text(encoding='utf-8').strip()
+                            by_version[version]['staged'] = [
+                                s.strip() for s in stage_content.split('\n')
+                                if s.strip() and not s.startswith('#')
+                            ]
+
+                        releases_info = dict(by_version)
+                finally:
+                    # Return to original branch
+                    if current_branch:
+                        try:
+                            self.hgit.checkout(current_branch)
+                        except:
+                            pass  # Best effort
 
             result['active_branches'] = self.hgit.get_active_branches_status(
                 stage_files=[info.get('stage_file') for info in releases_info.values()
@@ -1798,16 +1823,3 @@ See docs/half_orm_dev.md for complete documentation.
             raise RepoError(
                 f"Failed to restore database from schema: {e}"
             ) from e
-
-def temp_lock(func):
-    def wrapper(*args, **kwargs):
-        repo = Repo()
-        lock_tag = None
-        try:        
-            lock_tag = repo.hgit.acquire_branch_lock("ho-prod", timeout_minutes=30)
-            result = func(*args, **kwargs)
-            result['lock_tag'] = lock_tag
-        finally:
-            repo.hgit.release_branch_lock(lock_tag)
-        return result
-    return wrapper

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10}/half_orm_dev/utils.py

@@ -47,16 +47,3 @@ def resolve_database_config_name(base_dir):
 
     # Priority 3: directory name
     return base_path.name
-
-def lock_tag(repo: 'Repo'):
-    def temp_lock(func):
-        def wrapper(*args, **kwargs):
-            lock_tag = None
-            try:        
-                lock_tag = repo.hgit.acquire_branch_lock("ho-prod", timeout_minutes=30)
-                result = func(*args, **kwargs)
-            finally:
-                if lock_tag:
-                    repo.hgit.release_branch_lock(lock_tag)
-            return result
-        return wrapper

half_orm_dev-0.17.0a10/half_orm_dev/version.txt

@@ -0,0 +1 @@
+0.17.0-a10

{half_orm_dev-0.17.0a7 → half_orm_dev-0.17.0a10/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.0a7
+Version: 0.17.0a10
 Summary: half_orm development Framework.
 Home-page: https://github.com/collorg/halfORM_dev
 Author: Joël Maïzi

half_orm_dev-0.17.0a7/half_orm_dev/version.txt

@@ -1 +0,0 @@
-0.17.0-a7