half-orm-dev 1.0.0a7__tar.gz → 1.0.0a9__tar.gz

{half_orm_dev-1.0.0a7/half_orm_dev.egg-info → half_orm_dev-1.0.0a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a7
+Version: 1.0.0a9
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-1.0.0a7 → half_orm_dev-1.0.0a9}/half_orm_dev/cli/commands/migrate.py

@@ -134,6 +134,10 @@ def migrate(verbose: bool) -> None:
                             click.echo(f"  • {error}")
 
                     click.echo(f"\n✓ Synced .hop/ to active branches")
+
+                    deleted = result.get('orphaned_staged_deleted', [])
+                    if deleted:
+                        click.echo(f"✓ Deleted {len(deleted)} orphaned ho-staged branch(es)")
                 else:
                     click.echo(f"✓ {utils.Color.green('Repository is up to date')}")
 

{half_orm_dev-1.0.0a7 → half_orm_dev-1.0.0a9}/half_orm_dev/migration_manager.py

@@ -313,6 +313,9 @@ class MigrationManager:
                 f"Continuing with migration attempt."
             )
 
+        # Ensure all active branches are in sync with origin before touching anything
+        self._ensure_active_branches_synced()
+
         # Get pending migrations
         pending = self.get_pending_migrations(current_version, target_version)
 
@@ -452,6 +455,72 @@ class MigrationManager:
         except Exception:
             pass  # remote tag may already be gone
 
+    def _ensure_active_branches_synced(self) -> None:
+        """Verify all active branches are in sync with origin before migration.
+
+        Branches that are behind are fast-forwarded automatically (no local commits
+        at risk).  Branches that are ahead or diverged block the migration — the
+        developer must push or resolve before proceeding.
+
+        Raises:
+            MigrationManagerError: if any active branch is ahead or diverged.
+        """
+        repo = self._repo
+        git_repo = repo.hgit._HGit__git_repo
+        current_branch = git_repo.active_branch.name
+
+        try:
+            branches_status = repo.hgit.get_active_branches_status()
+        except Exception:
+            return  # can't determine status, proceed cautiously
+
+        patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])]
+        release_branches = [b['name'] for b in branches_status.get('release_branches', [])]
+        # ho-staged/* branches are frozen after merge — excluded from sync checks
+        active_branches = release_branches + patch_branches
+
+        blocked = []
+        for branch in active_branches:
+            try:
+                synced, status = repo.hgit.is_branch_synced(branch)
+                if synced:
+                    continue
+                if status == 'behind':
+                    # Fast-forward: no local commits at risk
+                    repo.hgit.checkout(branch)
+                    git_repo.git.merge('--ff-only', f'origin/{branch}')
+                elif status in ('ahead', 'diverged'):
+                    blocked.append((branch, status))
+            except Exception:
+                pass  # branch may not exist locally, skip
+
+        # Return to original branch
+        try:
+            repo.hgit.checkout(current_branch)
+        except Exception:
+            pass
+
+        if blocked:
+            ahead = [(b, s) for b, s in blocked if s == 'ahead']
+            diverged = [(b, s) for b, s in blocked if s == 'diverged']
+            parts = []
+            if ahead:
+                branch_list = ', '.join(b for b, _ in ahead)
+                parts.append(
+                    f"  Branches ahead of origin (unpushed commits) — push first:\n"
+                    + '\n'.join(f"    git push origin {b}" for b, _ in ahead)
+                )
+            if diverged:
+                parts.append(
+                    f"  Branches diverged from origin (local and remote have diverged) "
+                    f"— rebase or merge to resolve:\n"
+                    + '\n'.join(f"    {b}" for b, _ in diverged)
+                )
+            raise MigrationManagerError(
+                f"Migration blocked: active branches are not in sync with origin.\n"
+                + '\n'.join(parts)
+            )
+
     def _regenerate_modules_after_migration(
         self, from_version: str, to_version: str
     ) -> None:
@@ -468,50 +537,40 @@ class MigrationManager:
         package_name = repo.name
         package_dir = str(Path(repo.base_dir) / package_name)
 
-        # Regenerate all modules (idempotent thanks to global reset in generate())
-        _modules.generate(repo)
-
-        # Stage the entire package directory
-        repo.hgit.add(package_dir)
-
-        # Nothing changed — nothing to do
-        staged = git_repo.git.diff('--cached', '--name-only')
-        if not staged.strip():
-            return
-
-        # Commit on ho-prod
         commit_msg = (
             f"[HOP] Regenerate modules (migration {from_version} → {to_version})"
         )
-        repo.hgit.commit('-m', commit_msg)
-        repo.hgit.push_branch('ho-prod')
 
-        # Sync to all active branches
+        # Collect active branches before moving around
         try:
             branches_status = repo.hgit.get_active_branches_status()
         except Exception:
-            return
+            branches_status = {}
 
         patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])]
         release_branches = [b['name'] for b in branches_status.get('release_branches', [])]
-        staged_branches = [b['name'] for b in branches_status.get('staged_branches', [])]
-        target_branches = release_branches + patch_branches + staged_branches
+        # ho-staged/* branches are frozen after merge — excluded from module regeneration
+        all_branches = ['ho-prod'] + release_branches + patch_branches
 
-        sync_msg = (
-            f"[HOP] Sync modules from ho-prod (migration {from_version} → {to_version})"
-        )
-        for branch in target_branches:
+        for branch in all_branches:
             try:
                 repo.hgit.checkout(branch)
-                git_repo.git.checkout('ho-prod', '--', package_name)
+                # generate() reads existing files and preserves developer code sections
+                _modules.generate(repo)
                 repo.hgit.add(package_dir)
-                if not git_repo.git.status('--porcelain').strip():
+                if not git_repo.git.diff('--cached', '--name-only').strip():
                     continue
-                repo.hgit.commit('-m', sync_msg)
-                repo.hgit.push_branch(branch)
+                repo.hgit.commit('-m', commit_msg)
+                try:
+                    repo.hgit.push_branch(branch)
+                except Exception as push_err:
+                    sys.stderr.write(
+                        f"Warning: could not push {branch} after module regeneration "
+                        f"(diverged branch?): {push_err}\n"
+                    )
             except Exception as e:
                 sys.stderr.write(
-                    f"Warning: could not sync modules to {branch}: {e}\n"
+                    f"Warning: could not regenerate modules on {branch}: {e}\n"
                 )
 
         repo.hgit.checkout('ho-prod')

{half_orm_dev-1.0.0a7 → half_orm_dev-1.0.0a9}/half_orm_dev/release_manager.py

@@ -2768,13 +2768,17 @@ class ReleaseManager:
             print(f"Warning: Failed to delete release branch {release_branch}: {e}", file=sys.stderr)
 
         # Delete ho-staged/X branches for all patches that were in this release.
-        # These were created by merge_patch (renamed from ho-patch/X) and are no
-        # longer needed once the release reaches production.
+        # At this point the X.Y.Z-patches.toml is already gone (replaced by
+        # X.Y.Z.txt during production promotion), so we read the .txt file.
         version = release_branch.replace('ho-release/', '')
-        release_file = ReleaseFile(version, self._releases_dir)
-        if release_file.exists():
-            staged_patch_ids = release_file.get_patches(status="staged")
-            for patch_id in staged_patch_ids:
+        prod_txt = Path(self._releases_dir) / f"{version}.txt"
+        if prod_txt.exists():
+            patch_ids = [
+                line.strip()
+                for line in prod_txt.read_text(encoding='utf-8').splitlines()
+                if line.strip()
+            ]
+            for patch_id in patch_ids:
                 staged_branch = f"ho-staged/{patch_id}"
                 try:
                     if self._repo.hgit.branch_exists(staged_branch):
@@ -2786,6 +2790,49 @@ class ReleaseManager:
 
         return deleted_branches
 
+    def cleanup_orphaned_staged_branches(self) -> list:
+        """Delete every ho-staged/* branch whose patch ID is in any .txt release file.
+
+        A ho-staged/* branch is orphaned when its release has been promoted to
+        production (the patch ID appears in a X.Y.Z.txt file) but the branch
+        was never cleaned up — e.g. due to an interrupted promotion.
+
+        Returns:
+            List of deleted branch names.
+        """
+        releases_dir = Path(self._releases_dir)
+        git_repo = self._repo.hgit._HGit__git_repo
+
+        # Collect all patch IDs that are in production (.txt files)
+        prod_patch_ids: set = set()
+        for txt_file in releases_dir.glob("*.txt"):
+            for line in txt_file.read_text(encoding='utf-8').splitlines():
+                patch_id = line.strip()
+                if patch_id:
+                    prod_patch_ids.add(patch_id)
+
+        if not prod_patch_ids:
+            return []
+
+        deleted = []
+        for branch in list(git_repo.branches):
+            if not branch.name.startswith('ho-staged/'):
+                continue
+            patch_id = branch.name[len('ho-staged/'):]
+            if patch_id not in prod_patch_ids:
+                continue
+            try:
+                self._repo.hgit.delete_local_branch(branch.name)
+                self._repo.hgit.delete_remote_branch(branch.name)
+                deleted.append(branch.name)
+            except Exception as e:
+                print(
+                    f"Warning: Failed to delete orphaned {branch.name}: {e}",
+                    file=sys.stderr,
+                )
+
+        return deleted
+
     @with_dynamic_branch_lock(lambda self: "ho-prod")
     def promote_to_rc(self) -> dict:
         """

{half_orm_dev-1.0.0a7 → half_orm_dev-1.0.0a9}/half_orm_dev/repo.py

@@ -544,6 +544,14 @@ class Repo:
                 result['migration_run'] = True
                 result['errors'] = migration_result.get('errors', [])
 
+                # Clean up orphaned ho-staged/* branches (patch IDs in .txt = already in production)
+                if hasattr(self, 'release_manager'):
+                    try:
+                        deleted = self.release_manager.cleanup_orphaned_staged_branches()
+                        result['orphaned_staged_deleted'] = deleted
+                    except Exception:
+                        result['orphaned_staged_deleted'] = []
+
                 # Log success if not silent
                 if not silent:
                     if migration_result.get('migrations_applied'):
@@ -638,9 +646,8 @@ class Repo:
             patch_branches = [b['name'] for b in branches_status.get('patch_branches', [])]
             release_branches = [b['name'] for b in branches_status.get('release_branches', [])]
 
-            # All branches = ho-prod + release branches + patch branches + staged branches
-            staged_branches = [b['name'] for b in branches_status.get('staged_branches', [])]
-            all_branches = ['ho-prod'] + release_branches + patch_branches + staged_branches
+            # ho-staged/* branches are frozen after merge — excluded from sync
+            all_branches = ['ho-prod'] + release_branches + patch_branches
 
             # Filter release branches to avoid syncing to future versions
             # Extract version from source branch if it's a release branch
@@ -690,18 +697,10 @@ class Repo:
                 remote_ref = f"origin/{branch}"
                 try:
                     synced, status = self.hgit.is_branch_synced(branch)
-                    if not synced and status == "diverged":
-                        print(
-                            f"Warning: branch {branch} has diverged from origin. "
-                            f"Resetting to origin (source of truth).",
-                            file=sys.stderr
-                        )
-                    # Only reset when the remote is ahead of local ("behind") or
-                    # branches have diverged.  Never reset an "ahead" branch —
-                    # that would orphan local commits that have not been pushed
-                    # yet (e.g. the "Create patch directory" commit from
-                    # `hop patch create` before the first push).
-                    if not synced and status in ("behind", "diverged"):
+                    # Only fast-forward when origin is strictly ahead (no local commits
+                    # at risk). Never reset on diverged branches — that would destroy
+                    # unmerged local work.
+                    if not synced and status == "behind":
                         self.hgit._HGit__git_repo.git.reset('--hard', remote_ref)
                 except GitCommandError:
                     # Remote branch may not exist yet, continue without reset
@@ -1528,28 +1527,8 @@ class Repo:
             result = repo.check_and_update(force_check=True)
         """
 
-        # Check cache (only if not forced and silent mode)
-        cache_file = Path(self.__base_dir) / '.git' / '.half_orm_check_cache'
-        cache_hit = False
 
-        if silent and not force_check and cache_file.exists():
-            try:
-                last_check = float(cache_file.read_text().strip())
-                # Check once per day (86400 seconds)
-                if time.time() - last_check < 86400:
-                    cache_hit = True
-                    return {
-                        'hooks': {'installed': False, 'action': 'skipped'},
-                        'branches': {},
-                        'cache_hit': True
-                    }
-            except (ValueError, IOError):
-                pass
-
-        # Perform checks
-        result = {
-            'cache_hit': False
-        }
+        result = {}
 
         # 0. Update ho-prod from remote and fetch all branches
         # This ensures we have the latest hop_version and branch status
@@ -1724,19 +1703,21 @@ class Repo:
 
         result['stale_branches'] = stale_branches_result
 
+        # 3b. Delete orphaned ho-staged/* branches (patch in a .txt = already in production)
+        orphaned_staged_deleted = []
+        if not dry_run and hasattr(self, 'release_manager'):
+            try:
+                orphaned_staged_deleted = self.release_manager.cleanup_orphaned_staged_branches()
+            except Exception:
+                pass  # Best effort
+        result['orphaned_staged_deleted'] = orphaned_staged_deleted
+
         # 4. Check version (only for explicit checks, not silent)
         if not silent:
             result['version'] = self._check_version_update()
         else:
             result['version'] = None
 
-        # Update cache
-        if not dry_run and silent:
-            try:
-                cache_file.write_text(str(time.time()))
-            except IOError:
-                pass  # Best effort
-
         return result
 
     def _validate_package_name(self, package_name):

half_orm_dev-1.0.0a9/half_orm_dev/version.txt

@@ -0,0 +1 @@
+1.0.0-a9

{half_orm_dev-1.0.0a7 → half_orm_dev-1.0.0a9/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a7
+Version: 1.0.0a9
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

half_orm_dev-1.0.0a7/half_orm_dev/version.txt

@@ -1 +0,0 @@
-1.0.0-a7