Merge pull request #436 from lbedner/v0.5.2-rc2

v0.5.2-rc2

Author: lbedner

CLAUDE.md

@@ -32,7 +32,7 @@ Each generated project includes:
 
 ## Installation
 
-**Current Version**: v0.5.2-rc1
+**Current Version**: v0.5.2-rc2
 
 ```bash
 pip install aegis-stack

aegis/__init__.py

@@ -2,4 +2,4 @@
 Aegis Stack CLI - Component generation and project management tools.
 """
 
-__version__ = "0.5.2-rc1"
+__version__ = "0.5.2-rc2"

aegis/commands/update.py

@@ -18,7 +18,6 @@
 from ..core.copier_updater import (
     analyze_conflict_files,
     cleanup_backup_tag,
-    count_commits_between,
     create_backup_point,
     format_conflict_report,
     get_changelog,
@@ -156,29 +155,16 @@ def update_command(
         target_ref = resolve_version_to_ref(to_version, template_root)
         target_version_display = to_version
     else:
-        # Default to HEAD - Copier handles version detection via git describe
-        # This ensures unreleased commits are picked up (not just tagged releases)
-        target_ref = "HEAD"
-
-        # Show user-friendly version info
-        head_commit = resolve_ref_to_commit("HEAD", template_root)
+        # Default to latest release version (not HEAD, not prereleases)
+        # Prereleases (rc, alpha, beta) are only picked up via explicit --to-version
         latest = get_latest_version(template_root)
         if latest:
-            latest_commit = resolve_ref_to_commit(f"v{latest}", template_root)
-            if head_commit and latest_commit and head_commit == latest_commit:
-                target_version_display = f"{latest} (latest release)"
-            elif head_commit:
-                # Count commits ahead of latest tag
-                commits_ahead = count_commits_between(
-                    f"v{latest}", "HEAD", template_root
-                )
-                if commits_ahead > 0:
-                    target_version_display = f"{latest}+{commits_ahead} commits (HEAD)"
-                else:
-                    target_version_display = f"HEAD ({head_commit[:8]}...)"
-            else:
-                target_version_display = "HEAD (latest commit)"
+            target_ref = f"v{latest}"
+            target_version_display = f"{latest} (latest release)"
         else:
+            # Fallback to HEAD only if no versions found
+            target_ref = "HEAD"
+            head_commit = resolve_ref_to_commit("HEAD", template_root)
             if head_commit:
                 target_version_display = f"HEAD ({head_commit[:8]}...)"
             else:

aegis/core/copier_updater.py

@@ -347,31 +347,6 @@ def resolve_ref_to_commit(ref: str, repo_path: Path) -> str | None:
         return None
 
 
-def count_commits_between(from_ref: str, to_ref: str, repo_path: Path) -> int:
-    """
-    Count commits between two git references.
-
-    Args:
-        from_ref: Starting git reference (older commit)
-        to_ref: Ending git reference (newer commit)
-        repo_path: Path to git repository
-
-    Returns:
-        Number of commits between refs, or 0 if unable to count
-    """
-    try:
-        result = subprocess.run(
-            ["git", "rev-list", "--count", f"{from_ref}..{to_ref}"],
-            cwd=repo_path,
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        return int(result.stdout.strip())
-    except (subprocess.CalledProcessError, ValueError):
-        return 0
-
-
 def resolve_version_to_ref(
     version: str | None, template_root: Path | None = None
 ) -> str:

copier.yml

@@ -6,7 +6,7 @@
 # - Update support
 
 _min_copier_version: "9.0.0"
-_version: "0.5.2-rc1"
+_version: "0.5.2-rc2"
 
 # IMPORTANT: Template content is in subdirectory
 # This allows the template to be recognized as git-tracked (aegis-stack repo root has .git)

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aegis-stack"
-version = "0.5.2-rc1"
+version = "0.5.2-rc2"
 description = "A production-ready Python foundation for builders who refuse to wait. Try: uvx aegis-stack init my-project"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

tests/core/test_copier_updater.py

@@ -16,6 +16,8 @@
     cleanup_backup_tag,
     create_backup_point,
     format_conflict_report,
+    get_available_versions,
+    get_latest_version,
     rollback_to_backup,
 )
 
@@ -352,3 +354,150 @@ def test_returns_fallback_on_invalid_ref(self) -> None:
         # Should contain fallback message with "Changelog not available" or actual changelog
         assert isinstance(result, str)
         assert "Changelog not available" in result or "Changes:" in result
+
+
+@pytest.fixture
+def git_repo_with_tags(tmp_path: Path) -> Path:
+    """Initialize a git repository with version tags (including prereleases)."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    subprocess.run(
+        ["git", "config", "user.email", "test@test.com"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+    )
+    subprocess.run(
+        ["git", "config", "user.name", "Test"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+    )
+
+    # Create a copier.yml to make it a valid template root
+    (tmp_path / "copier.yml").write_text("_subdirectory: templates\n")
+
+    # Create initial commit and tags
+    (tmp_path / "test.txt").write_text("v0.1.0")
+    subprocess.run(["git", "add", "."], cwd=tmp_path, capture_output=True, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "v0.1.0"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "tag", "v0.1.0"], cwd=tmp_path, capture_output=True, check=True
+    )
+
+    # Add more commits and tags
+    (tmp_path / "test.txt").write_text("v0.2.0")
+    subprocess.run(["git", "add", "."], cwd=tmp_path, capture_output=True, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "v0.2.0"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "tag", "v0.2.0"], cwd=tmp_path, capture_output=True, check=True
+    )
+
+    # Add a prerelease tag
+    (tmp_path / "test.txt").write_text("v0.3.0rc1")
+    subprocess.run(["git", "add", "."], cwd=tmp_path, capture_output=True, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "v0.3.0rc1"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+    )
+    subprocess.run(
+        ["git", "tag", "v0.3.0rc1"], cwd=tmp_path, capture_output=True, check=True
+    )
+
+    # Add another prerelease
+    (tmp_path / "test.txt").write_text("v0.3.0-alpha.1")
+    subprocess.run(["git", "add", "."], cwd=tmp_path, capture_output=True, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "v0.3.0-alpha.1"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+    )
+    subprocess.run(
+        ["git", "tag", "v0.3.0-alpha.1"], cwd=tmp_path, capture_output=True, check=True
+    )
+
+    return tmp_path
+
+
+class TestGetAvailableVersions:
+    """Tests for get_available_versions function."""
+
+    def test_returns_versions_sorted_newest_first(
+        self, git_repo_with_tags: Path
+    ) -> None:
+        """Test that versions are returned sorted newest first."""
+        versions = get_available_versions(git_repo_with_tags)
+
+        # Should get 0.2.0 and 0.1.0 (no prereleases by default)
+        assert len(versions) == 2
+        assert versions[0] == "0.2.0"  # Newest first
+        assert versions[1] == "0.1.0"
+
+    def test_excludes_prereleases_by_default(self, git_repo_with_tags: Path) -> None:
+        """Test that prereleases are excluded by default."""
+        versions = get_available_versions(git_repo_with_tags)
+
+        # Should NOT contain rc or alpha versions
+        assert "0.3.0rc1" not in versions
+        assert "0.3.0-alpha.1" not in versions
+
+    def test_includes_prereleases_when_requested(
+        self, git_repo_with_tags: Path
+    ) -> None:
+        """Test that prereleases are included when include_prereleases=True."""
+        versions = get_available_versions(git_repo_with_tags, include_prereleases=True)
+
+        # Should contain all versions including prereleases
+        assert "0.3.0rc1" in versions
+        assert "0.3.0-alpha.1" in versions
+        assert "0.2.0" in versions
+        assert "0.1.0" in versions
+
+    def test_returns_empty_for_no_tags(self, git_repo: Path) -> None:
+        """Test that empty list is returned when no version tags exist."""
+        # Create copier.yml to make it a valid template root
+        (git_repo / "copier.yml").write_text("_subdirectory: templates\n")
+        subprocess.run(["git", "add", "."], cwd=git_repo, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add copier.yml"],
+            cwd=git_repo,
+            capture_output=True,
+        )
+
+        versions = get_available_versions(git_repo)
+
+        assert versions == []
+
+
+class TestGetLatestVersion:
+    """Tests for get_latest_version function."""
+
+    def test_returns_latest_non_prerelease_version(
+        self, git_repo_with_tags: Path
+    ) -> None:
+        """Test that latest version is 0.2.0, not a prerelease."""
+        latest = get_latest_version(git_repo_with_tags)
+
+        # Should be 0.2.0, NOT 0.3.0rc1 or 0.3.0-alpha.1
+        assert latest == "0.2.0"
+
+    def test_returns_none_for_no_versions(self, git_repo: Path) -> None:
+        """Test that None is returned when no version tags exist."""
+        # Create copier.yml to make it a valid template root
+        (git_repo / "copier.yml").write_text("_subdirectory: templates\n")
+        subprocess.run(["git", "add", "."], cwd=git_repo, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", "Add copier.yml"],
+            cwd=git_repo,
+            capture_output=True,
+        )
+
+        latest = get_latest_version(git_repo)
+
+        assert latest is None