half-orm-dev 0.17.2a5__tar.gz → 0.17.2a7__tar.gz

{half_orm_dev-0.17.2a5/half_orm_dev.egg-info → half_orm_dev-0.17.2a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.2a5
+Version: 0.17.2a7
 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.2a5 → half_orm_dev-0.17.2a7}/half_orm_dev/cli/commands/__init__.py

@@ -13,6 +13,7 @@ from .release import release
 from .update import update
 from .upgrade import upgrade
 from .check import check
+from .migrate import migrate
 from .todo import apply_release
 from .todo import rollback
 
@@ -30,6 +31,7 @@ ALL_COMMANDS = {
     'update': update,          # Adapted for production
     'upgrade': upgrade,          # Adapted for production
     'check': check,            # Project health check and updates
+    'migrate': migrate,        # Repository migration after upgrade
     # 🚧 (stubs)
     'apply_release': apply_release,
 
@@ -49,6 +51,7 @@ __all__ = [
     'release',
     'upgrade',
     'check',
+    'migrate',
     'rollback',
     # Adapted commands
     'sync_package',

half_orm_dev-0.17.2a7/half_orm_dev/cli/commands/migrate.py

@@ -0,0 +1,125 @@
+"""
+Migrate command - Apply repository migrations after half_orm_dev upgrade.
+
+This command runs pending migrations when the installed half_orm_dev version
+is newer than the repository's hop_version in .hop/config.
+"""
+
+import click
+from half_orm_dev.repo import Repo, RepoError
+from half_orm import utils
+
+
+@click.command()
+@click.option(
+    '--verbose', '-v',
+    is_flag=True,
+    help='Show detailed migration information'
+)
+def migrate(verbose: bool) -> None:
+    """
+    Apply repository migrations after half_orm_dev upgrade.
+
+    This command updates the repository structure and configuration files
+    when you upgrade to a newer version of half_orm_dev.
+
+    Requirements:
+      • Must be on ho-prod branch
+      • Repository must be clean (no uncommitted changes)
+
+    Process:
+      1. Detects version mismatch between installed half_orm_dev and repository
+      2. Applies any migration scripts for intermediate versions
+      3. Updates hop_version in .hop/config
+      4. Creates migration commit on ho-prod
+      5. Syncs .hop/ directory to all active branches
+
+    Examples:
+        # After upgrading half_orm_dev
+        $ pip install --upgrade half_orm_dev
+        $ half_orm dev migrate
+        ⚠️  Migration needed: half_orm_dev 0.17.2 → 0.18.0
+          Current branch: ho-prod
+
+          Running migrations...
+          ✓ Applied migration: 0.17.2 → 0.18.0
+          ✓ Updated .hop/config: hop_version = 0.18.0
+          ✓ Synced .hop/ to active branches
+
+        # View detailed migration info
+        $ half_orm dev migrate --verbose
+    """
+    try:
+        repo = Repo()
+
+        # Check if we're in a repository
+        if not repo.checked:
+            click.echo(utils.Color.red("❌ Not in a hop repository"), err=True)
+            raise click.Abort()
+
+        # Get current versions
+        from half_orm_dev.utils import hop_version
+        installed_version = hop_version()
+        config_version = repo._Repo__config.hop_version if hasattr(repo, '_Repo__config') else '0.0.0'
+
+        # Check if migration is needed
+        comparison = repo.compare_versions(installed_version, config_version)
+
+        if comparison == 0:
+            # Versions are equal - no migration needed
+            click.echo(f"✓ {utils.Color.green('Repository is up to date')}")
+            click.echo(f"  Repository version: {config_version}")
+            click.echo(f"  Installed version:  {installed_version}")
+            return
+
+        elif comparison < 0:
+            # Installed version is OLDER than repository version
+            click.echo(f"⚠️  {utils.Color.red('Installed half_orm_dev is older than repository version')}", err=True)
+            click.echo(f"\n  Repository version: {config_version}", err=True)
+            click.echo(f"  Installed version:  {installed_version}", err=True)
+            click.echo(f"\n  Please upgrade half_orm_dev:", err=True)
+            click.echo(f"    pip install --upgrade half_orm_dev\n", err=True)
+            raise click.Abort()
+
+        # Migration needed (comparison > 0)
+        click.echo(f"⚠️  {utils.Color.bold('Migration needed:')}")
+        click.echo(f"  half_orm_dev {config_version} → {installed_version}")
+
+        # Check current branch
+        current_branch = repo.hgit.branch if repo.hgit else 'unknown'
+        click.echo(f"  Current branch: {current_branch}")
+        click.echo()
+
+        # Run migrations
+        click.echo(f"  Running migrations...")
+
+        try:
+            result = repo.run_migrations_if_needed(silent=False)
+
+            if result['migration_run']:
+                click.echo(f"\n✓ {utils.Color.green('Migration completed successfully')}")
+                click.echo(f"  Updated .hop/config: hop_version = {installed_version}")
+
+                if verbose and result.get('errors'):
+                    click.echo(f"\n⚠️  Warnings during migration:")
+                    for error in result['errors']:
+                        click.echo(f"  • {error}")
+
+                click.echo(f"\n✓ Synced .hop/ to active branches")
+            else:
+                click.echo(f"✓ {utils.Color.green('Repository is up to date')}")
+
+        except RepoError as e:
+            # Migration failed or branch check failed
+            click.echo(utils.Color.red(f"\n❌ {e}"), err=True)
+            raise click.Abort()
+
+    except RepoError as e:
+        click.echo(utils.Color.red(f"❌ Error: {e}"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(utils.Color.red(f"❌ Unexpected error: {e}"), err=True)
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        raise click.Abort()

half_orm_dev-0.17.2a7/half_orm_dev/cli/main.py

@@ -0,0 +1,190 @@
+"""
+Main CLI module - Creates and configures the CLI group
+"""
+
+import click
+import functools
+from half_orm_dev.repo import Repo, OutdatedHalfORMDevError
+from half_orm import utils
+from .commands import ALL_COMMANDS
+
+
+class Hop:
+    """Sets the options available to the hop command"""
+
+    def __init__(self):
+        self.__repo: Repo = None
+        self.__hop_upgrade_error: OutdatedHalfORMDevError = None
+
+        # Try to initialize Repo, catch version errors
+        try:
+            self.__repo = Repo()  # Utilise le singleton
+        except OutdatedHalfORMDevError as e:
+            # Capture the error but don't raise it yet
+            self.__hop_upgrade_error = e
+
+        self.__available_cmds = self._determine_available_commands()
+
+    def _determine_available_commands(self):
+        """
+        Determine which commands are available based on context.
+
+        Returns different command sets based on:
+        - Repository status (checked/unchecked)
+        - Development mode (devel flag - metadata presence)
+        - Environment (production flag)
+
+        Note: When needs_hop_upgrade is true, commands will still be added
+        but will be blocked by the decorator at execution time.
+        """
+        if self.needs_hop_upgrade:
+            # Version downgrade detected - return a minimal set of commands
+            # Commands will be blocked by decorator, but we need them in the list
+            # so Click doesn't show "No such command" error
+            return ['check', 'migrate']
+
+        if not self.repo_checked:
+            # Outside hop repository - commands for project initialization
+            return ['init', 'clone']
+
+        if self.__repo.needs_migration():
+            return ['migrate']
+
+        # Inside hop repository
+        if not self.__repo.devel:
+            # Sync-only mode (no metadata)
+            return ['sync-package', 'check']
+
+        # Development mode (metadata present)
+        if self.__repo.database.production:
+            # PRODUCTION ENVIRONMENT - Release deployment only
+            return ['update', 'upgrade', 'check']
+        else:
+            # DEVELOPMENT ENVIRONMENT - Patch development
+            return ['patch', 'release', 'check']
+
+    @property
+    def repo_checked(self):
+        """Returns whether we are in a repo or not."""
+        return self.__repo and self.__repo.checked
+
+    @property
+    def needs_hop_upgrade(self):
+        """Returns whether half_orm_dev needs to be upgraded."""
+        return self.__hop_upgrade_error is not None
+
+    @property
+    def hop_upgrade_error(self):
+        """Returns the upgrade error if any."""
+        return self.__hop_upgrade_error
+
+    @property
+    def state(self):
+        """Returns the state of the repo."""
+        return self.__repo.state if self.__repo else "Not in a repository"
+
+    @property
+    def available_commands(self):
+        """Returns the list of available commands."""
+        return self.__available_cmds
+
+
+def create_cli_group():
+    """
+    Creates and returns the CLI group with appropriate commands.
+
+    Returns:
+        click.Group: Configured CLI group
+    """
+    hop = Hop()
+
+    def check_version_before_invoke(f, allow_on_downgrade=False):
+        """Decorator to check version before invoking any command.
+
+        Args:
+            f: Function to wrap
+            allow_on_downgrade: If True, allow this command even when version is outdated
+        """
+        @functools.wraps(f)
+        def wrapper(*args, **kwargs):
+            if hop.needs_hop_upgrade and not allow_on_downgrade:
+                # Display formatted error message for version downgrade
+                error = hop.hop_upgrade_error
+                click.echo("=" * 70, err=True)
+                click.echo(f"{utils.Color.red('❌ OUTDATED half_orm_dev VERSION')}", err=True)
+                click.echo("=" * 70, err=True)
+                click.echo(f"\n  Repository requires: {utils.Color.bold(error.required_version)}", err=True)
+                click.echo(f"  Installed version:   {utils.Color.bold(error.installed_version)}", err=True)
+                click.echo(f"\n  Your installed version is OLDER than the repository requirement.", err=True)
+                click.echo(f"  All commands are blocked for safety.", err=True)
+                click.echo(f"\n  Please upgrade half_orm_dev:", err=True)
+                click.echo(f"    {utils.Color.bold('pip install --upgrade half_orm_dev')}", err=True)
+                click.echo("\n" + "=" * 70 + "\n", err=True)
+                raise click.Abort()
+            return f(*args, **kwargs)
+        return wrapper
+
+    # Create custom Group that auto-decorates commands
+    class VersionCheckGroup(click.Group):
+        def add_command(self, cmd, name=None):
+            """Override to decorate all commands with version check."""
+            if isinstance(cmd, click.Command) and cmd.callback:
+                cmd.callback = check_version_before_invoke(cmd.callback)
+            super().add_command(cmd, name)
+
+    @click.group(cls=VersionCheckGroup, invoke_without_command=True)
+    @click.pass_context
+    @check_version_before_invoke
+    def dev(ctx):
+        """halfORM development tools - Git-centric patch management and database synchronization"""
+        if ctx.invoked_subcommand is None:
+            # Show repo state when no subcommand is provided
+            if hop.repo_checked:
+                # Check if migration is needed
+                if hop._Hop__repo.needs_migration():
+                    # Display migration warning
+                    from half_orm_dev.utils import hop_version
+                    installed_version = hop_version()
+                    config_version = hop._Hop__repo._Repo__config.hop_version
+                    current_branch = hop._Hop__repo.hgit.branch if hop._Hop__repo.hgit else 'unknown'
+
+                    click.echo(f"\n{'='*70}")
+                    click.echo(f"⚠️  {utils.Color.bold(utils.Color.red('REPOSITORY MIGRATION REQUIRED'))} ⚠️")
+                    click.echo(f"{'='*70}")
+                    click.echo(f"\n  Repository version: {utils.Color.red(config_version)}")
+                    click.echo(f"  Installed version:  {utils.Color.green(installed_version)}")
+                    click.echo(f"  Current branch:     {current_branch}")
+                    click.echo(f"\n  {utils.Color.bold('All commands are blocked until migration is complete.')}")
+                    click.echo(f"\n  To apply migration, run:")
+                    click.echo(f"    {utils.Color.bold('half_orm dev migrate')}")
+                    click.echo(f"\n{'='*70}\n")
+                else:
+                    # Normal display
+                    click.echo(hop.state)
+                    click.echo(f"\n{utils.Color.bold('Available commands:')}")
+
+                    # Adapt displayed commands based on environment
+                    if hop._Hop__repo.database.production:
+                        # Production commands
+                        click.echo(f"  • {utils.Color.bold('update')} - Fetch and list available releases")
+                        click.echo(f"  • {utils.Color.bold('upgrade [--to-release=X.Y.Z]')} - Apply releases to production")
+                    else:
+                        # Development commands
+                        click.echo(f"  • {utils.Color.bold('patch')}")
+                        click.echo(f"  • {utils.Color.bold('prepare-release <level>')} - Prepare next release stage file (patch/minor/major)")
+                        click.echo(f"  • {utils.Color.bold('promote-to <target>')} - Promote stage to rc or prod")
+
+                    click.echo(f"\nTry {utils.Color.bold('half_orm dev <command> --help')} for more information.\n")
+            else:
+                click.echo(hop.state)
+                click.echo("\nNot in a hop repository.")
+                click.echo(f"\n{utils.Color.bold('Available commands:')}")
+                click.echo(f"\n  • {utils.Color.bold('init <package_name>')} - Create new halfORM project.")
+                click.echo(f"\n  • {utils.Color.bold('clone <git origin>')} - Clone an existing halfORM project.\n")
+
+    # Add only available commands to the group
+    for cmd_name in hop.available_commands:
+        if cmd_name in ALL_COMMANDS:
+            dev.add_command(ALL_COMMANDS[cmd_name])
+
+    return dev

{half_orm_dev-0.17.2a5 → half_orm_dev-0.17.2a7}/half_orm_dev/migration_manager.py

@@ -25,6 +25,7 @@ import re
 import subprocess
 import sys
 import importlib.util
+from packaging import version
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
 from half_orm import utils
@@ -58,38 +59,6 @@ class MigrationManager:
         # Path to migrations directory (in half_orm_dev package)
         self._migrations_root = Path(__file__).parent / 'migrations'
 
-    def _parse_version(self, version_str: str) -> Tuple[int, int, int]:
-        """
-        Parse version string to tuple.
-
-        Supports version formats:
-        - "0.17.1"
-        - "0.1.0a1" (ignores suffix)
-        - "0.17.1-a1" (ignores suffix)
-        - "0.17.1-rc2" (ignores suffix)
-
-        Args:
-            version_str: Version string like "0.17.1" or "0.17.1-a1"
-
-        Returns:
-            Tuple of (major, minor, patch)
-        """
-        # Strip any pre-release suffix (e.g., "-a1", "-rc2")
-        base_version = version_str.split('-')[0]
-        if not re.match(r"^\d+\.\d+\.\d+$", base_version):
-            match = re.match(r"^(\d+\.\d+\.\d+)", base_version)
-            if match:
-                base_version = match.group(1)
-
-        parts = base_version.split('.')
-        if len(parts) != 3:
-            raise MigrationManagerError(f"Invalid version format: {version_str}")
-
-        try:
-            return (int(parts[0]), int(parts[1]), int(parts[2]))
-        except ValueError as e:
-            raise MigrationManagerError(f"Invalid version format: {version_str}") from e
-
     def _version_to_path(self, version: Tuple[int, int, int]) -> Path:
         """
         Convert version tuple to migration directory path.
@@ -117,8 +86,8 @@ class MigrationManager:
         Returns:
             List of (version_str, migration_dir_path) tuples in order
         """
-        current = self._parse_version(current_version)
-        target = self._parse_version(target_version)
+        current = version.parse(current_version).release
+        target = version.parse(target_version).release
 
         pending = []
 
@@ -298,8 +267,19 @@ class MigrationManager:
         ) else "0.0.0"
 
         # If already at target version, nothing to do
-        if current_version == target_version:
-            return result
+        try:
+            comparison = self._repo.compare_versions(current_version, target_version)
+
+            if comparison >= 0:
+                # Already at or past target version (0 = equal, 1 = higher)
+                return result
+        except Exception as e:
+            # If version comparison fails (invalid format), log and continue
+            # This allows migration to proceed even if version format is unexpected
+            result['errors'].append(
+                f"Could not compare versions {current_version} and {target_version}: {e}. "
+                f"Continuing with migration attempt."
+            )
 
         # Get pending migrations
         pending = self.get_pending_migrations(current_version, target_version)
@@ -392,21 +372,39 @@ class MigrationManager:
         Check if migration is needed.
 
         Compares current tool version with hop_version in .hop/config.
+        Properly handles pre-release versions (alpha, beta, rc).
 
         Args:
-            current_tool_version: Current half_orm_dev version
+            current_tool_version: Current half_orm_dev version (e.g., "0.17.2-a5")
 
         Returns:
-            True if migration is needed
+            True if migration/update is needed
         """
         if not hasattr(self._repo, '_Repo__config'):
             return False
 
         config_version = self._repo._Repo__config.hop_version
 
-        # Parse versions
-        current = self._parse_version(current_tool_version)
-        config = self._parse_version(config_version)
+        # If no hop_version is configured, no migration needed
+        if not config_version:
+            return False
 
-        # Migration needed if current version is higher
-        return current > config
+        try:
+            # Use Repo's centralized comparison method
+            # Returns: 1 if current > config, 0 if equal, -1 if current < config
+            comparison = self._repo.compare_versions(current_tool_version, config_version)
+
+            # Migration needed if current version is higher
+            # This now properly compares: 0.17.2a5 > 0.17.2a3 → returns 1 ✓
+            return comparison > 0
+
+        except Exception as e:
+            # If version parsing fails, log warning and don't block
+            import warnings
+            warnings.warn(
+                f"Could not parse versions for migration check: "
+                f"current={current_tool_version}, config={config_version}. "
+                f"Error: {e}",
+                UserWarning
+            )
+            return False

{half_orm_dev-0.17.2a5 → half_orm_dev-0.17.2a7}/half_orm_dev/repo.py

@@ -37,6 +37,17 @@ from .utils import TEMPLATE_DIRS, hop_version, resolve_database_config_name
 class RepoError(Exception):
     pass
 
+class OutdatedHalfORMDevError(RepoError):
+    """Raised when installed half_orm_dev version is older than repository requirement."""
+    def __init__(self, required_version: str, installed_version: str):
+        self.required_version = required_version
+        self.installed_version = installed_version
+        super().__init__(
+            f"Repository requires half_orm_dev >= {required_version} "
+            f"but {installed_version} is installed.\n"
+            f"Please upgrade: pip install --upgrade half_orm_dev"
+        )
+
 class Config:
     """
     """
@@ -257,8 +268,12 @@ class Repo:
                 if self.devel:
                     self.hgit = HGit(self)
                 self.__checked = True
-                # Perform automatic migration if needed (after hgit is initialized)
-                self._run_pending_migrations()
+                # NOTE: Migration is no longer automatic - user must run `half_orm dev migrate`
+                # This prevents implicit changes and gives user control over when migration happens
+
+                # Automatically check and update hooks/config (silent, uses cache)
+                # This ensures Git hooks are always up-to-date for all commands
+                self.check_and_update(silent=True)
                 return
             par_dir = os.path.split(base_dir)[0]
             if par_dir == base_dir:
@@ -290,13 +305,13 @@ class Repo:
         installed_version = hop_version()
 
         try:
-            if version.parse(installed_version) < version.parse(required_version):
-                raise RepoError(
-                    f"Repository requires half_orm_dev >= {required_version} "
-                    f"but {installed_version} is installed.\n"
-                    f"Please upgrade: pip install --upgrade half_orm_dev"
-                )
-        except version.InvalidVersion as e:
+            # Use centralized comparison method
+            if self.compare_versions(installed_version, required_version) < 0:
+                raise OutdatedHalfORMDevError(required_version, installed_version)
+        except OutdatedHalfORMDevError:
+            # Re-raise downgrade errors immediately
+            raise
+        except RepoError as e:
             # If version parsing fails, log warning but don't block
             warnings.warn(
                 f"Could not parse version: installed={installed_version}, "
@@ -304,61 +319,179 @@ class Repo:
                 UserWarning
             )
 
-    def _run_pending_migrations(self):
+    def compare_versions(self, version1: str, version2: str) -> int:
+        """
+        Compare two version strings using packaging.version.
+
+        Properly handles pre-release versions (alpha, beta, rc) according to PEP 440.
+
+        Args:
+            version1: First version string (e.g., "0.17.2-a5")
+            version2: Second version string (e.g., "0.17.2-a3")
+
+        Returns:
+            -1 if version1 < version2
+             0 if version1 == version2
+             1 if version1 > version2
+
+        Raises:
+            RepoError: If either version string is invalid
+
+        Examples:
+            >>> repo.compare_versions("0.17.2-a5", "0.17.2-a3")
+            1  # 0.17.2a5 > 0.17.2a3
+            >>> repo.compare_versions("0.17.2", "0.17.2-a5")
+            1  # 0.17.2 > 0.17.2a5 (release > pre-release)
+            >>> repo.compare_versions("0.17.1", "0.17.2")
+            -1  # 0.17.1 < 0.17.2
+            >>> repo.compare_versions("0.17.2", "0.17.2")
+            0  # Equal
+        """
+        try:
+            v1 = version.parse(version1)
+            v2 = version.parse(version2)
+
+            if v1 < v2:
+                return -1
+            elif v1 > v2:
+                return 1
+            else:
+                return 0
+
+        except version.InvalidVersion as e:
+            raise RepoError(
+                f"Invalid version format: {e}"
+            ) from e
+
+    def needs_migration(self) -> bool:
+        """
+        Check if repository needs migration.
+
+        Compares installed half_orm_dev version with repository's hop_version.
+
+        Returns:
+            True if installed version > repository version (migration needed)
+            False otherwise
+
+        Examples:
+            >>> repo.needs_migration()
+            True  # Installed 0.18.0, repo at 0.17.2
+        """
+        if not hasattr(self, '_Repo__config') or not self.__config:
+            return False
+
+        installed_version = hop_version()
+        config_version = self.__config.hop_version
+
+        if not config_version:
+            return False
+
+        try:
+            return self.compare_versions(installed_version, config_version) > 0
+        except RepoError:
+            # If version comparison fails, assume no migration needed
+            return False
+
+    def run_migrations_if_needed(self, silent: bool = False) -> dict:
         """
         Run pending migrations using MigrationManager.
 
-        Automatically detects and runs migrations based on current
-        half_orm_dev version vs hop_version in .hop/config.
+        Detects and runs migrations based on current half_orm_dev version
+        vs hop_version in .hop/config.
 
         Behavior:
-        - On ho-prod: Runs migration with lock, creates commit, notifies active branches
-        - On other branches: Warns user to merge ho-prod to get migration
+        - On ho-prod: Runs migration with lock, creates commit, syncs to active branches
+        - On other branches: Raises RepoError directing user to checkout ho-prod
+
+        Args:
+            silent: If True, suppress informational messages (only show errors)
+
+        Returns:
+            dict with keys:
+                - migration_needed: bool - True if migration was needed
+                - migration_run: bool - True if migration was executed
+                - target_version: str - Target version migrated to
+                - errors: list - Any errors encountered
+
+        Raises:
+            RepoError: If not on ho-prod branch and migration is needed
+
+        Examples:
+            # Run migration (raises if not on ho-prod)
+            result = repo.run_migrations_if_needed()
 
-        Silent by default - only logs errors.
+            # Check result
+            if result['migration_run']:
+                print(f"Migrated to {result['target_version']}")
         """
+        result = {
+            'migration_needed': False,
+            'migration_run': False,
+            'target_version': None,
+            'errors': []
+        }
+
         try:
             # Create migration manager
             migration_mgr = MigrationManager(self)
 
             # Get current half_orm_dev version
             current_version = hop_version()
+            result['target_version'] = current_version
 
             # Check if migration is needed
             if not migration_mgr.check_migration_needed(current_version):
-                return
+                return result
+
+            result['migration_needed'] = True
 
             # Only run migrations on ho-prod branch
             if not self.hgit or self.hgit.branch != 'ho-prod':
-                # Warn user to switch to ho-prod to run migration
+                # Raise error directing user to checkout ho-prod
                 current_branch = self.hgit.branch if self.hgit else 'unknown'
                 config_version = self.__config.hop_version if hasattr(self, '_Repo__config') else '0.0.0'
-                print(f"\n{utils.Color.bold('⚠️  Migration needed:')}", file=sys.stderr)
-                print(f"  half_orm_dev {config_version} → {current_version}", file=sys.stderr)
-                print(f"  Current branch: {current_branch}", file=sys.stderr)
-                print(f"\n  To apply migration, checkout to ho-prod branch and rerun:", file=sys.stderr)
-                print(f"    git checkout ho-prod", file=sys.stderr)
-                print(f"    half_orm dev check\n", file=sys.stderr)
-                return
+                raise RepoError(
+                    f"Repository migration required\n\n"
+                    f"  Repository version: {config_version}\n"
+                    f"  Installed version:  {current_version}\n"
+                    f"  Current branch:     {current_branch}\n\n"
+                    f"  Please checkout to ho-prod branch and run:\n"
+                    f"    git checkout ho-prod\n"
+                    f"    half_orm dev migrate\n"
+                )
 
             # Run migrations on ho-prod
             # Branch sync is handled automatically by the decorator
-            result = migration_mgr.run_migrations(
+            migration_result = migration_mgr.run_migrations(
                 target_version=current_version,
                 create_commit=True
             )
 
-            # Log errors if any
-            if result.get('errors'):
-                for error in result['errors']:
-                    print(f"Migration error: {error}", file=sys.stderr)
+            result['migration_run'] = True
+            result['errors'] = migration_result.get('errors', [])
+
+            # Log success if not silent
+            if not silent:
+                if migration_result.get('migrations_applied'):
+                    print(f"✓ Applied {len(migration_result['migrations_applied'])} migration(s)")
+                else:
+                    print(f"✓ Updated repository version to {current_version}")
 
+        except RepoError:
+            # Re-raise RepoError (for branch check)
+            raise
         except MigrationManagerError as e:
-            # Log migration errors but don't fail repo initialization
-            print(f"Migration failed: {e}", file=sys.stderr)
+            # Log migration errors
+            error_msg = f"Migration failed: {e}"
+            result['errors'].append(error_msg)
+            raise RepoError(error_msg) from e
         except Exception as e:
             # Catch any unexpected errors
-            print(f"Unexpected migration error: {e}", file=sys.stderr)
+            error_msg = f"Unexpected migration error: {e}"
+            result['errors'].append(error_msg)
+            raise RepoError(error_msg) from e
+
+        return result
 
     def sync_hop_to_active_branches(self, reason: str = "update") -> dict:
         """
@@ -998,6 +1131,9 @@ class Repo:
         hooks_source_dir = os.path.join(TEMPLATE_DIRS, 'git-hooks')
         hooks_dest_dir = os.path.join(self.__base_dir, '.git', 'hooks')
 
+        # Create .git/hooks directory if it doesn't exist
+        os.makedirs(hooks_dest_dir, exist_ok=True)
+
         any_installed = False
         overall_action = 'skipped'
 
@@ -2093,6 +2229,7 @@ See docs/half_orm_dev.md for complete documentation.
             5. Create .hop/alt_config if custom database_name provided
             6. Setup database (create + metadata if create_db=True)
             7. Restore database from model/schema.sql to production version
+            8. Install Git hooks (pre-commit, prepare-commit-msg)
 
         Examples:
             # Interactive with prompts for connection params
@@ -2216,3 +2353,6 @@ See docs/half_orm_dev.md for complete documentation.
             raise RepoError(
                 f"Failed to restore database from schema: {e}"
             ) from e
+
+        # Step 9: Install Git hooks
+        repo.install_git_hooks()

{half_orm_dev-0.17.2a5 → half_orm_dev-0.17.2a7}/half_orm_dev/templates/git-hooks/pre-commit

@@ -3,11 +3,48 @@
 # Half-ORM pre-commit hook
 # 1. Checks if current ho-* branch exists on remote origin
 # 2. Protects ho-prod branch from direct commits
+# 3. Optionally calls pre-commit-custom if it exists
 # Generated by half_orm_dev
 
 # Get current branch
 CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null)
 
+# =============================================================================
+# CUSTOM PRE-COMMIT HOOK SUPPORT
+# =============================================================================
+# If a pre-commit-custom script exists in .git/hooks/, execute it first.
+# This allows users to add their own custom checks (linting, formatting, etc.)
+#
+# ⚠️  WARNING: pre-commit-custom is NOT tracked by Git and NOT cloned.
+# It must be added manually to each local repository clone.
+#
+# To create a custom hook:
+#   1. Create .git/hooks/pre-commit-custom (executable)
+#   2. Add your custom checks
+#   3. Exit with 0 (success) or non-zero (failure) to block the commit
+#
+# Example .git/hooks/pre-commit-custom:
+#   #!/usr/bin/env bash
+#   # Run Python linter
+#   python -m pylint $(git diff --cached --name-only --diff-filter=ACM | grep '\.py$')
+#   exit $?
+# =============================================================================
+
+CUSTOM_HOOK=".git/hooks/pre-commit-custom"
+if [ -x "$CUSTOM_HOOK" ]; then
+    "$CUSTOM_HOOK"
+    CUSTOM_EXIT_CODE=$?
+    if [ $CUSTOM_EXIT_CODE -ne 0 ]; then
+        echo ""
+        echo "❌ Custom pre-commit hook failed (exit code: $CUSTOM_EXIT_CODE)"
+        exit $CUSTOM_EXIT_CODE
+    fi
+fi
+
+# =============================================================================
+# HALF-ORM STANDARD CHECKS
+# =============================================================================
+
 # Check if current ho-* branch (except ho-prod) still exists on remote origin
 # This prevents committing to ho-* branches that were deleted remotely
 if [[ "$CURRENT_BRANCH" == ho-* ]] && [ "$CURRENT_BRANCH" != "ho-prod" ]; then

half_orm_dev-0.17.2a7/half_orm_dev/version.txt

@@ -0,0 +1 @@
+0.17.2-a7

{half_orm_dev-0.17.2a5 → half_orm_dev-0.17.2a7/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.2a5
+Version: 0.17.2a7
 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.2a5 → half_orm_dev-0.17.2a7}/half_orm_dev.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ half_orm_dev/cli/commands/apply.py
 half_orm_dev/cli/commands/check.py
 half_orm_dev/cli/commands/clone.py
 half_orm_dev/cli/commands/init.py
+half_orm_dev/cli/commands/migrate.py
 half_orm_dev/cli/commands/new.py
 half_orm_dev/cli/commands/patch.py
 half_orm_dev/cli/commands/release.py

half_orm_dev-0.17.2a5/half_orm_dev/cli/main.py

@@ -1,103 +0,0 @@
-"""
-Main CLI module - Creates and configures the CLI group
-"""
-
-import click
-from half_orm_dev.repo import Repo
-from half_orm import utils
-from .commands import ALL_COMMANDS
-
-
-class Hop:
-    """Sets the options available to the hop command"""
-
-    def __init__(self):
-        self.__repo: Repo = Repo()  # Utilise le singleton
-        self.__available_cmds = self._determine_available_commands()
-
-    def _determine_available_commands(self):
-        """
-        Determine which commands are available based on context.
-
-        Returns different command sets based on:
-        - Repository status (checked/unchecked)
-        - Development mode (devel flag - metadata presence)
-        - Environment (production flag)
-        """
-        if not self.repo_checked:
-            # Outside hop repository - commands for project initialization
-            return ['init', 'clone']
-
-        # Inside hop repository
-        if not self.__repo.devel:
-            # Sync-only mode (no metadata)
-            return ['sync-package', 'check']
-
-        # Development mode (metadata present)
-        if self.__repo.database.production:
-            # PRODUCTION ENVIRONMENT - Release deployment only
-            return ['update', 'upgrade', 'check']
-        else:
-            # DEVELOPMENT ENVIRONMENT - Patch development
-            return ['patch', 'release', 'check']
-
-    @property
-    def repo_checked(self):
-        """Returns whether we are in a repo or not."""
-        return self.__repo.checked
-
-    @property
-    def state(self):
-        """Returns the state of the repo."""
-        return self.__repo.state
-
-    @property
-    def available_commands(self):
-        """Returns the list of available commands."""
-        return self.__available_cmds
-
-
-def create_cli_group():
-    """
-    Creates and returns the CLI group with appropriate commands.
-
-    Returns:
-        click.Group: Configured CLI group
-    """
-    hop = Hop()
-
-    @click.group(invoke_without_command=True)
-    @click.pass_context
-    def dev(ctx):
-        """halfORM development tools - Git-centric patch management and database synchronization"""
-        if ctx.invoked_subcommand is None:
-            # Show repo state when no subcommand is provided
-            if hop.repo_checked:
-                click.echo(hop.state)
-                click.echo(f"\n{utils.Color.bold('Available commands:')}")
-
-                # Adapt displayed commands based on environment
-                if hop.__repo.database.production:
-                    # Production commands
-                    click.echo(f"  • {utils.Color.bold('update')} - Fetch and list available releases")
-                    click.echo(f"  • {utils.Color.bold('upgrade [--to-release=X.Y.Z]')} - Apply releases to production")
-                else:
-                    # Development commands
-                    click.echo(f"  • {utils.Color.bold('patch')}")
-                    click.echo(f"  • {utils.Color.bold('prepare-release <level>')} - Prepare next release stage file (patch/minor/major)")
-                    click.echo(f"  • {utils.Color.bold('promote-to <target>')} - Promote stage to rc or prod")
-
-                click.echo(f"\nTry {utils.Color.bold('half_orm dev <command> --help')} for more information.\n")
-            else:
-                click.echo(hop.state)
-                click.echo("\nNot in a hop repository.")
-                click.echo(f"\n{utils.Color.bold('Available commands:')}")
-                click.echo(f"\n  • {utils.Color.bold('init <package_name>')} - Create new halfORM project.")
-                click.echo(f"\n  • {utils.Color.bold('clone <git origin>')} - Clone an existing halfORM project.\n")
-
-    # Add only available commands to the group
-    for cmd_name in hop.available_commands:
-        if cmd_name in ALL_COMMANDS:
-            dev.add_command(ALL_COMMANDS[cmd_name])
-
-    return dev

half_orm_dev-0.17.2a5/half_orm_dev/version.txt

@@ -1 +0,0 @@
-0.17.2-a5