half-orm-dev 0.17.0a14__tar.gz → 0.17.0a15__tar.gz

{half_orm_dev-0.17.0a14/half_orm_dev.egg-info → half_orm_dev-0.17.0a15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.0a14
+Version: 0.17.0a15
 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-0.17.0a14 → half_orm_dev-0.17.0a15}/half_orm_dev/cli/commands/check.py

@@ -14,11 +14,6 @@ from half_orm import utils
 
 
 @click.command()
-@click.option(
-    '--prune-branches', '-p',
-    is_flag=True,
-    help='Also clean up local branches that no longer exist on remote'
-)
 @click.option(
     '--dry-run',
     is_flag=True,
@@ -29,7 +24,7 @@ from half_orm import utils
     is_flag=True,
     help='Show detailed information'
 )
-def check(prune_branches: bool, dry_run: bool, verbose: bool) -> None:
+def check(dry_run: bool, verbose: bool) -> None:
     """
     Verify and update project configuration.
 
@@ -39,15 +34,12 @@ def check(prune_branches: bool, dry_run: bool, verbose: bool) -> None:
     Checks performed:
       • Git hooks are up to date (pre-commit)
       • Repository is properly configured
-      • Optionally: Clean up stale local branches
+      • Detect and prompt to clean up stale local branches
 
     Examples:
         # Basic check and update
         half_orm dev check
 
-        # Check and clean up stale branches
-        half_orm dev check --prune-branches
-
         # Preview what would be done
         half_orm dev check --dry-run
     """
@@ -56,13 +48,12 @@ def check(prune_branches: bool, dry_run: bool, verbose: bool) -> None:
 
         # Perform check (delegates to Repo)
         result = repo.check_and_update(
-            prune_branches=prune_branches,
             dry_run=dry_run,
             silent=False  # Show messages
         )
 
         # Display results
-        _display_check_results(result, dry_run, prune_branches, verbose)
+        _display_check_results(repo, result, dry_run, verbose)
 
     except Exception as e:
         click.echo(utils.Color.red(f"❌ Error: {e}"), err=True)
@@ -72,9 +63,9 @@ def check(prune_branches: bool, dry_run: bool, verbose: bool) -> None:
         raise click.Abort()
 
 
-def _display_check_results(result: dict, dry_run: bool, prune_branches: bool, verbose: bool):
+def _display_check_results(repo, result: dict, dry_run: bool, verbose: bool):
     """Display check results to user."""
-    # Version check
+    # Version check - display first and potentially interrupt
     version_info = result.get('version')
     if version_info:
         current = version_info.get('current_version')
@@ -86,8 +77,25 @@ def _display_check_results(result: dict, dry_run: bool, prune_branches: bool, ve
             if verbose:
                 click.echo(f"ℹ {utils.Color.blue(f'Version check: {error}')}")
         elif update_available and latest:
-            click.echo(f"⚠ {utils.Color.bold(f'half_orm_dev: {current}')} {utils.Color.bold(f'(update available: {latest})')}")
-            click.echo(f"  Run: {utils.Color.bold('pip install --upgrade half_orm_dev')}")
+            # Critical update notice - display prominently at the top
+            click.echo()
+            click.echo(f"{'='*70}")
+            click.echo(f"⚠️  {utils.Color.bold('UPDATE AVAILABLE')} ⚠️")
+            click.echo(f"{'='*70}")
+            click.echo(f"Current version: {utils.Color.bold(current)}")
+            click.echo(f"Latest version:  {utils.Color.green(utils.Color.bold(latest))}")
+            click.echo()
+            click.echo(f"To update, run: {utils.Color.bold('pip install --upgrade half_orm_dev')}")
+            click.echo(f"{'='*70}")
+            click.echo()
+
+            # Prompt user to update now
+            if click.confirm("Do you want to interrupt and update now?", default=False):
+                click.echo(f"\nℹ️  Please run the following command:")
+                click.echo(f"   {utils.Color.bold('pip install --upgrade half_orm_dev')}")
+                click.echo()
+                raise click.Abort()
+
             click.echo()
         elif current:
             click.echo(f"✓ {utils.Color.green(f'half_orm_dev: {current} (latest)')}")
@@ -139,30 +147,57 @@ def _display_check_results(result: dict, dry_run: bool, prune_branches: bool, ve
         if len(stale_release) > 5:
             click.echo(f"  ... and {len(stale_release) - 5} more")
 
-    # Prune results
-    if prune_branches:
-        branches = result.get('branches', {})
-        deleted = branches.get('deleted', [])
-
-        if deleted:
+    # Stale branches detection and cleanup
+    stale_branches = result.get('stale_branches', {})
+    candidates = stale_branches.get('candidates', [])
+
+    if candidates:
+        click.echo()
+        if dry_run:
+            click.echo(f"⚠️  {utils.Color.bold(f'Found {len(candidates)} stale local branch(es)')} (no longer on remote):")
+            for branch in candidates[:10]:
+                click.echo(f"  ○ {branch}")
+            if len(candidates) > 10:
+                click.echo(f"  ... and {len(candidates) - 10} more")
+            click.echo(f"\n  Run without --dry-run to be prompted for deletion")
+        else:
+            # Show stale branches and prompt for deletion
+            click.echo(f"⚠️  {utils.Color.bold(f'Found {len(candidates)} stale local branch(es)')} (no longer on remote):")
+            for branch in candidates[:10]:
+                click.echo(f"  • {branch}")
+            if len(candidates) > 10:
+                click.echo(f"  ... and {len(candidates) - 10} more")
             click.echo()
-            if dry_run:
-                click.echo(f"○ {utils.Color.blue(f'Would delete {len(deleted)} stale branch(es)')}")
-            else:
-                click.echo(f"✓ {utils.Color.green(f'Deleted {len(deleted)} stale branch(es)')}")
 
-            if verbose:
-                for branch in deleted[:10]:
-                    symbol = "○" if dry_run else "✓"
-                    click.echo(f"  {symbol} {branch}")
-                if len(deleted) > 10:
-                    click.echo(f"  ... and {len(deleted) - 10} more")
-
-        if branches.get('errors'):
-            click.echo(f"⚠ {utils.Color.red('Some errors occurred during cleanup')}")
-            if verbose:
-                for branch, error in branches['errors'][:3]:
-                    click.echo(f"  {branch}: {error}")
+            # Prompt for confirmation
+            if click.confirm(f"Delete these {len(candidates)} branch(es)?", default=False):
+                # Get repo instance and actually delete the branches
+                deleted = []
+                errors = []
+                try:
+                    delete_result = repo.hgit.prune_local_branches(
+                        pattern="ho-*",
+                        dry_run=False,
+                        exclude_current=True
+                    )
+                    deleted = delete_result.get('deleted', [])
+                    errors = delete_result.get('errors', [])
+
+                    if deleted:
+                        click.echo(f"\n✓ {utils.Color.green(f'Deleted {len(deleted)} stale branch(es)')}")
+                        if verbose:
+                            for branch in deleted[:10]:
+                                click.echo(f"  ✓ {branch}")
+                            if len(deleted) > 10:
+                                click.echo(f"  ... and {len(deleted) - 10} more")
+
+                    if errors:
+                        click.echo(f"\n⚠ {utils.Color.red('Some errors occurred during cleanup')}")
+                        if verbose:
+                            for branch, error in errors[:3]:
+                                click.echo(f"  {branch}: {error}")
+                except Exception as e:
+                    click.echo(utils.Color.red(f"\n❌ Error deleting branches: {e}"), err=True)
 
 
 def _display_release_branches_grouped(branches: list, verbose: bool):
@@ -263,10 +298,23 @@ def _display_releases_with_patches(releases_info: dict, patch_branches: list, re
         # 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':
+            sync_status = release_branch_info.get('sync_status', 'unknown')
+            ahead = release_branch_info.get('ahead', 0)
+            behind = release_branch_info.get('behind', 0)
+            exists_on_remote = release_branch_info.get('exists_on_remote', False)
+
+            if not exists_on_remote:
+                release_status = f" {utils.Color.bold('⚠️ local only - remote deleted')}"
+            elif sync_status == 'remote_only':
                 release_status = f" {utils.Color.blue('☁️ on remote only')}"
+            elif sync_status == 'synced':
+                release_status = f" {utils.Color.green('✓ synced')}"
+            elif sync_status == 'ahead':
+                release_status = f" {utils.Color.blue(f'↑ {ahead} ahead')}"
+            elif sync_status == 'behind':
+                release_status = f" {utils.Color.blue(f'↓ {behind} behind')}"
+            elif sync_status == 'diverged':
+                release_status = f" {utils.Color.red(f'⚠ diverged (↑{ahead} ↓{behind})')}"
         else:
             # Release files exist but no branch at all
             release_status = f" {utils.Color.red('⚠️ branch not found')}"
@@ -303,7 +351,7 @@ def _display_releases_with_patches(releases_info: dict, patch_branches: list, re
                     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 + ")")
+                        status = utils.Color.bold("⚠️ local only (remote deleted or not pushed - run: git branch -d " + branch_name + ")")
                     else:
                         status = "?"
 

{half_orm_dev-0.17.0a14 → half_orm_dev-0.17.0a15}/half_orm_dev/cli/commands/upgrade.py

@@ -132,7 +132,7 @@ def _display_upgrade_results(result):
         final = result['final_version']
         click.echo(f"\nWould upgrade: {current} → {utils.Color.green(final)}")
 
-        click.echo(f"\n{utils.Color.yellow('To apply this upgrade, run without --dry-run')}")
+        click.echo(f"\n{utils.Color.bold('To apply this upgrade, run without --dry-run')}")
         return
 
     # === ACTUAL UPGRADE ===
@@ -147,7 +147,7 @@ def _display_upgrade_results(result):
         # Up to date scenario
         pass
     else:
-        click.echo(f"⚠️  {utils.Color.yellow('No backup created (--skip-backup used)')}")
+        click.echo(f"⚠️  {utils.Color.bold('No backup created (--skip-backup used)')}")
 
     click.echo(f"\nCurrent version: {utils.Color.bold(current)}")
 

{half_orm_dev-0.17.0a14 → half_orm_dev-0.17.0a15}/half_orm_dev/patch_manager.py

@@ -2104,13 +2104,13 @@ class PatchManager:
 
         except FileNotFoundError:
             # pytest not installed - warn but don't block
-            click.echo(f"  • {utils.Color.yellow('⚠')} pytest not found (install pytest to run tests)")
+            click.echo(f"  • {utils.Color.bold('⚠')} pytest not found (install pytest to run tests)")
         except PatchManagerError:
             # Re-raise our own exceptions (test failures)
             raise
         except Exception as e:
             # Any other error - warn but don't block (might be environment issue)
-            click.echo(f"  • {utils.Color.yellow('⚠')} Failed to run tests: {e} (continuing anyway)")
+            click.echo(f"  • {utils.Color.bold('⚠')} Failed to run tests: {e} (continuing anyway)")
 
         # Note: KeyboardInterrupt (Ctrl+C) is not caught here - it inherits from
         # BaseException, not Exception, so it will propagate up to the decorator

{half_orm_dev-0.17.0a14 → half_orm_dev-0.17.0a15}/half_orm_dev/release_manager.py

@@ -110,10 +110,10 @@ class ReleaseManager:
     - X.Y.Z-hotfix[N].txt: Emergency hotfix (immutable)
 
     Examples:
-        # Prepare new release
+        # Create new release
         release_mgr = ReleaseManager(repo)
-        result = release_mgr.prepare_release('minor')
-        # Creates releases/1.4.0-stage.txt
+        result = release_mgr.new_release('minor')
+        # Creates branch ho-release/1.4.0
 
         # Find latest version
         version = release_mgr.find_latest_version()
@@ -135,148 +135,6 @@ class ReleaseManager:
         self._base_dir = str(repo.base_dir)
         self._releases_dir = Path(repo.base_dir) / "releases"
 
-    def prepare_release(self, increment_type: str) -> dict:
-        """
-        Prepare next release stage file.
-
-        Creates new releases/X.Y.Z-stage.txt file based on latest version
-        and increment type. Validates repository state, synchronizes with
-        origin, and pushes to reserve version globally.
-
-        Workflow:
-        0. Acquire lock tag
-        1. Validate on ho-prod branch
-        2. Validate repository is clean
-        3. Fetch from origin
-        4. Synchronize with origin/ho-prod (pull if behind)
-        5. Read production version from model/schema.sql
-        6. Calculate next version based on increment type
-        7. Verify stage file doesn't already exist
-        8. Create empty stage file
-        9. Commit with message "Prepare release X.Y.Z-stage"
-        10. Push to origin (global reservation)
-        11. Release lock tag
-
-        Branch requirements:
-        - Must be on ho-prod branch
-        - Repository must be clean (no uncommitted changes)
-        - Must be synced with origin/ho-prod (auto-pull if behind)
-
-        Synchronization behavior:
-        - "synced": Continue
-        - "behind": Auto-pull with message
-        - "ahead": Continue (will push at end)
-        - "diverged": Error - manual merge required
-
-        Args:
-            increment_type: Version increment ("major", "minor", or "patch")
-
-        Returns:
-            dict: Preparation result with keys:
-                - version: New version string (e.g., "1.4.0")
-                - file: Path to created stage file
-                - previous_version: Previous production version
-
-        Raises:
-            ReleaseManagerError: If validation fails
-            ReleaseManagerError: If not on ho-prod branch
-            ReleaseManagerError: If repository not clean
-            ReleaseManagerError: If ho-prod diverged from origin
-            ReleaseFileError: If stage file already exists
-            ReleaseVersionError: If version calculation fails
-
-        Examples:
-            # Prepare minor release
-            result = release_mgr.prepare_release('minor')
-            # Production was 1.3.5 → creates releases/1.4.0-stage.txt
-
-            # Prepare patch release
-            result = release_mgr.prepare_release('patch')
-            # Production was 1.3.5 → creates releases/1.3.6-stage.txt
-
-            # Error handling
-            try:
-                result = release_mgr.prepare_release('major')
-            except ReleaseManagerError as e:
-                print(f"Failed: {e}")
-        """
-        try:
-            # 0. ACQUIRE LOCK on ho-prod (with 30 min timeout for stale locks)
-            lock_tag = self._repo.hgit.acquire_branch_lock("ho-prod", timeout_minutes=30)
-
-            # 1. Validate on ho-prod branch
-            if self._repo.hgit.branch != 'ho-prod':
-                raise ReleaseManagerError(
-                    f"Must be on ho-prod branch to prepare release.\n"
-                    f"Current branch: {self._repo.hgit.branch}\n"
-                    f"Switch to ho-prod: git checkout ho-prod"
-                )
-
-            # 2. Validate repository is clean
-            if not self._repo.hgit.repos_is_clean():
-                raise ReleaseManagerError(
-                    "Repository has uncommitted changes.\n"
-                    "Commit or stash changes before preparing release:\n"
-                    "  git status\n"
-                    "  git add . && git commit"
-                )
-
-            # 3. Fetch from origin
-            self._repo.hgit.fetch_from_origin()
-
-            # 4. Synchronize with origin
-            is_synced, status = self._repo.hgit.is_branch_synced("ho-prod")
-
-            if status == "behind":
-                # Pull automatically
-                self._repo.hgit.pull()
-            elif status == "diverged":
-                raise ReleaseManagerError(
-                    "ho-prod has diverged from origin/ho-prod.\n"
-                    "Manual resolution required:\n"
-                    "  git pull --rebase origin ho-prod\n"
-                    "  or\n"
-                    "  git merge origin/ho-prod"
-                )
-            # If "synced" or "ahead", continue
-
-            # 5. Read production version from model/schema.sql
-            prod_version_str = self._get_production_version()
-
-            # Parse into Version object for calculation
-            prod_version = self.parse_version_from_filename(f"{prod_version_str}.txt")
-
-            # 6. Calculate next version
-            next_version = self.calculate_next_version(prod_version, increment_type)
-
-            # 7. Verify stage file doesn't exist
-            stage_file = self._releases_dir / f"{next_version}-stage.txt"
-            if stage_file.exists():
-                raise ReleaseFileError(
-                    f"Stage file already exists: {stage_file}\n"
-                    f"Version {next_version} is already in development.\n"
-                    f"To continue with this version, use existing stage file."
-                )
-
-            # 8. Create empty stage file
-            stage_file.touch()
-
-            # 9. Commit
-            self._repo.hgit.add(str(stage_file))
-            self._repo.hgit.commit("-m", f"Prepare release {next_version}-stage")
-
-            # 10. Push to origin (global reservation)
-            self._repo.hgit.push()
-            # Return result
-            return {
-                'version': next_version,
-                'file': str(stage_file),
-                'previous_version': prod_version_str
-            }
-
-        finally:
-            # 11. ALWAYS release lock (even on error)
-            self._repo.hgit.release_branch_lock(lock_tag)
 
 
     def _get_production_version(self) -> str:
@@ -377,6 +235,199 @@ class ReleaseManager:
 
         return version
 
+    def _check_and_init_from_database(self) -> bool:
+        """
+        Check for legacy project and offer to initialize from database.
+
+        For projects migrating from half_orm 0.13.x, this method detects when ALL
+        three required elements are missing (releases/, model/, ho-prod branch) and
+        offers to initialize them from the existing database metadata.
+
+        Workflow:
+        1. Check if releases/, model/, and ho-prod all exist
+        2. If ALL THREE are missing, prompt user to initialize from database
+        3. Create ho-prod branch from current branch
+        4. Read production version from half_orm_meta.view.hop_last_release
+        5. Create releases/ and model/ directories
+        6. Generate schema and metadata files using Database._generate_schema_sql()
+        7. Create releases/X.Y.Z.txt EMPTY (production release)
+        8. Commit the initialization
+
+        Returns:
+            bool: True if initialization was performed, False if skipped
+
+        Raises:
+            ReleaseManagerError: If database not accessible or initialization fails
+            ReleaseManagerError: If project is in inconsistent state (only some parts exist)
+
+        Examples:
+            # Migrating old project
+            if release_mgr._check_and_init_from_database():
+                print("Initialized from database")
+            else:
+                print("Already initialized")
+        """
+        import click
+        from half_orm import utils
+
+        # Check what exists
+        releases_exists = self._releases_dir.exists()
+        model_dir = Path(self._base_dir) / "model"
+        model_exists = model_dir.exists() and (model_dir / "schema.sql").exists()
+        ho_prod_exists = self._repo.hgit.branch_exists("ho-prod")
+
+        # If all three exist, no initialization needed
+        if releases_exists and model_exists and ho_prod_exists:
+            return False
+
+        # If only some exist, the project is in an inconsistent state
+        if releases_exists or model_exists or ho_prod_exists:
+            missing = []
+            if not releases_exists:
+                missing.append("releases/")
+            if not model_exists:
+                missing.append("model/")
+            if not ho_prod_exists:
+                missing.append("ho-prod branch")
+
+            existing = []
+            if releases_exists:
+                existing.append("releases/")
+            if model_exists:
+                existing.append("model/")
+            if ho_prod_exists:
+                existing.append("ho-prod branch")
+
+            raise ReleaseManagerError(
+                f"Project in inconsistent state.\n\n"
+                f"Missing: {', '.join(missing)}\n"
+                f"Present: {', '.join(existing)}\n\n"
+                f"For legacy migration, all three must be missing.\n"
+                f"Please either:\n"
+                f"  • Complete the setup manually, or\n"
+                f"  • Remove existing elements to start fresh initialization"
+            )
+
+        # All three missing - offer to initialize from database
+        click.echo(f"\n{utils.Color.bold('⚠ Legacy project detected')}")
+        click.echo("The releases/ and model/ directories are missing.")
+        click.echo("This appears to be a project from half_orm 0.13.x or earlier.")
+        click.echo()
+        click.echo("I can initialize the workflow from your existing database:")
+        click.echo("  • Create ho-prod branch (if needed)")
+        click.echo("  • Read production version from half_orm_meta.view.hop_last_release")
+        click.echo("  • Create releases/ and model/ directories")
+        click.echo("  • Generate schema and metadata files")
+        click.echo("  • Create initial production release file")
+        click.echo()
+
+        if not click.confirm("Initialize from database?", default=True):
+            raise ReleaseManagerError(
+                "Cannot proceed without releases/ directory.\n"
+                "Run this command again and confirm initialization, or\n"
+                "manually create the releases/ directory structure."
+            )
+
+        try:
+            # Ensure ho-prod branch exists
+            click.echo(f"\n{utils.Color.bold('Checking ho-prod branch...')}")
+            current_branch = self._repo.hgit.branch
+            if not self._repo.hgit.branch_exists("ho-prod"):
+                click.echo(f"  Creating ho-prod branch from {current_branch}...")
+                try:
+                    self._repo.hgit.create_branch("ho-prod", from_branch=current_branch)
+                    click.echo(f"  {utils.Color.green('✓ Created ho-prod branch')}")
+
+                    # Push to remote if exists
+                    if self._repo.hgit.has_remote():
+                        self._repo.hgit.push_branch("ho-prod")
+                        click.echo(f"  {utils.Color.green('✓ Pushed ho-prod to origin')}")
+
+                    # Switch to ho-prod
+                    self._repo.hgit.checkout("ho-prod")
+                except Exception as e:
+                    raise ReleaseManagerError(f"Failed to create ho-prod branch: {e}")
+            else:
+                click.echo(f"  ✓ ho-prod branch already exists")
+                # Switch to ho-prod
+                if current_branch != "ho-prod":
+                    self._repo.hgit.checkout("ho-prod")
+
+            # Read production version from database
+            click.echo(f"\n{utils.Color.bold('Reading version from database...')}")
+            try:
+                version_str = self._repo.database.last_release_s
+                click.echo(f"  Production version: {utils.Color.green(version_str)}")
+            except Exception as e:
+                raise ReleaseManagerError(
+                    f"Failed to read version from database.\n"
+                    f"Error: {e}\n\n"
+                    f"Ensure:\n"
+                    f"  • Database is accessible\n"
+                    f"  • half_orm_meta schema exists\n"
+                    f"  • hop_last_release view is populated"
+                )
+
+            # Create directories
+            click.echo(f"\n{utils.Color.bold('Creating directories...')}")
+            self._releases_dir.mkdir(parents=True, exist_ok=True)
+            click.echo(f"  ✓ Created {self._releases_dir}")
+            model_dir.mkdir(parents=True, exist_ok=True)
+            click.echo(f"  ✓ Created {model_dir}")
+
+            # Generate schema and metadata files using existing method
+            click.echo(f"\n{utils.Color.bold('Generating schema files...')}")
+            try:
+                self._repo.database._generate_schema_sql(version_str, model_dir)
+                click.echo(f"  ✓ Generated schema-{version_str}.sql")
+                click.echo(f"  ✓ Generated metadata-{version_str}.sql")
+                click.echo(f"  ✓ Created symlink: schema.sql -> schema-{version_str}.sql")
+            except Exception as e:
+                raise ReleaseManagerError(f"Failed to generate schema files: {e}")
+
+            # Create empty production release file
+            click.echo(f"\n{utils.Color.bold('Creating release file...')}")
+            release_file = self._releases_dir / f"{version_str}.txt"
+            release_file.touch()
+            click.echo(f"  ✓ Created {release_file.name} (empty - production release)")
+
+            # Commit initialization
+            click.echo(f"\n{utils.Color.bold('Committing initialization...')}")
+            self._repo.hgit.add(str(self._releases_dir))
+            self._repo.hgit.add(str(model_dir))
+            self._repo.hgit.commit(
+                "-m",
+                f"chore: initialize releases/ and model/ from database (version {version_str})"
+            )
+            click.echo(f"  {utils.Color.green('✓ Initialization committed')}")
+
+            # Create production tag for this version
+            click.echo(f"\n{utils.Color.bold('Creating production tag...')}")
+            prod_tag = f"v{version_str}"
+            self._repo.hgit.create_tag(prod_tag, f"Production release {version_str} (migrated from database)")
+            click.echo(f"  {utils.Color.green(f'✓ Created tag {prod_tag}')}")
+
+            # Push if remote exists
+            if self._repo.hgit.has_remote():
+                click.echo(f"\n{utils.Color.bold('Pushing to origin...')}")
+                self._repo.hgit.push()
+                self._repo.hgit.push_tag(prod_tag)
+                click.echo(f"  {utils.Color.green('✓ Pushed to origin')}")
+                click.echo(f"  {utils.Color.green(f'✓ Pushed tag {prod_tag}')}")
+
+            click.echo(f"\n{utils.Color.green('✓ Successfully initialized from database!')}")
+            click.echo()
+
+            return True
+
+        except Exception as e:
+            # Clean up on error
+            if self._releases_dir.exists() and not any(self._releases_dir.iterdir()):
+                self._releases_dir.rmdir()
+            if model_dir.exists() and not any(model_dir.iterdir()):
+                model_dir.rmdir()
+            raise ReleaseManagerError(f"Initialization failed: {e}")
+
     def find_latest_version(self) -> Optional[Version]:
         """
         Find latest version across all release stages.
@@ -2365,6 +2416,7 @@ class ReleaseManager:
         dependencies between patches.
 
         Workflow:
+        0. Check for legacy project migration (auto-initialize if needed)
         1. Calculate next version based on level (major/minor/patch)
         2. Create release branch ho-release/{version} from ho-prod
         3. Push release branch to remote
@@ -2393,15 +2445,19 @@ class ReleaseManager:
             # → Creates empty 0.1.0-stage.txt
             # → Switches to ho-release/0.1.0
         """
+        # 0. Check for legacy project migration
+        was_initialized = self._check_and_init_from_database()
+
         # Calculate next version
         version = self._calculate_next_version(level)
         release_branch = f"ho-release/{version}"
 
-        # Ensure we're on ho-prod
-        try:
-            self._repo.hgit.checkout("ho-prod")
-        except Exception as e:
-            raise ReleaseManagerError(f"Failed to checkout ho-prod: {e}")
+        # Ensure we're on ho-prod (unless we just initialized and are already there)
+        if not was_initialized or self._repo.hgit.branch != "ho-prod":
+            try:
+                self._repo.hgit.checkout("ho-prod")
+            except Exception as e:
+                raise ReleaseManagerError(f"Failed to checkout ho-prod: {e}")
 
         # Create empty candidates file (NEW)
         candidates_file = self._releases_dir / f"{version}-candidates.txt"