Merge pull request #439 from lbedner/v0.5.2-rc5

v0.5.2-rc5

Author: lbedner

CLAUDE.md

@@ -32,7 +32,7 @@ Each generated project includes:
 
 ## Installation
 
-**Current Version**: v0.5.2-rc4
+**Current Version**: v0.5.2-rc5
 
 ```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-rc4"
+__version__ = "0.5.2-rc5"

aegis/commands/update.py

@@ -31,7 +31,10 @@
     validate_clean_git_tree,
 )
 from ..core.post_gen_tasks import cleanup_components, run_post_generation_tasks
-from ..core.template_cleanup import cleanup_nested_project_directory
+from ..core.template_cleanup import (
+    cleanup_nested_project_directory,
+    sync_template_changes,
+)
 from ..core.version_compatibility import get_cli_version, get_project_template_version
 
 
@@ -335,6 +338,16 @@ def update_command(
                 # files and cleanup_components removes those not selected in answers
                 cleanup_components(target_path, answers)
 
+        # Sync template changes that Copier's git apply may have missed
+        # This handles the case where the {{ project_slug }}/ directory is excluded
+        # from git apply because it only contains ignored files
+        template_src = answers.get("_src_path", "gh:lbedner/aegis-stack")
+        synced_files = sync_template_changes(
+            target_path, answers, template_src, target_ref
+        )
+        if synced_files:
+            typer.echo(f"   Synced {len(synced_files)} template changes")
+
         # Run post-generation tasks
         # Determine what services need migrations
         include_auth = answers.get(AnswerKeys.AUTH, False)

aegis/core/template_cleanup.py

@@ -6,6 +6,7 @@
 """
 
 import shutil
+import tempfile
 from pathlib import Path
 
 from .verbosity import verbose_print
@@ -90,3 +91,125 @@ def cleanup_nested_project_directory(
             verbose_print(f"   Warning: Could not remove {project_slug}/")
 
     return files_moved
+
+
+def sync_template_changes(
+    project_path: Path,
+    answers: dict,
+    template_src: str,
+    vcs_ref: str,
+) -> list[str]:
+    """
+    Sync template changes that Copier's git apply may have missed.
+
+    Copier's update mechanism uses `git apply` with exclusions based on
+    `git status --ignored`. When the template uses a {{ project_slug }}/
+    wrapper, and the nested directory contains only ignored files, the
+    entire project slug directory gets excluded from the patch.
+
+    This function works around that by:
+    1. Rendering the new template to a temp directory
+    2. Comparing files between project and rendered template
+    3. Updating project files that differ from template
+
+    Note: This function only syncs EXISTING files. New files are handled by
+    cleanup_nested_project_directory() which must run BEFORE this function.
+    The update command (aegis/commands/update.py) ensures this ordering.
+
+    Args:
+        project_path: Path to project root
+        answers: Copier answers dict (from .copier-answers.yml)
+        template_src: Template source (e.g., "gh:user/repo")
+        vcs_ref: Git ref for template version (e.g., "v0.5.2-rc4")
+
+    Returns:
+        List of relative file paths that were updated
+    """
+    from copier import run_copy
+
+    project_slug = answers.get("project_slug", "")
+    if not project_slug:
+        return []
+
+    files_updated: list[str] = []
+
+    # Create temp directory for rendered template
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+
+        # Render the new template version
+        try:
+            run_copy(
+                src_path=template_src,
+                dst_path=str(temp_path),
+                data=answers,
+                defaults=True,
+                overwrite=True,
+                unsafe=False,
+                vcs_ref=vcs_ref,
+                quiet=True,
+            )
+        except Exception as e:
+            verbose_print(f"   Warning: Could not render template for sync: {e}")
+            return []
+
+        # The rendered template is in temp_path/project_slug/
+        rendered_dir = temp_path / project_slug
+        if not rendered_dir.exists():
+            return []
+
+        # Compare and sync files
+        for template_file in rendered_dir.rglob("*"):
+            if template_file.is_dir():
+                continue
+
+            # Skip certain files that shouldn't be synced
+            relative = template_file.relative_to(rendered_dir)
+            if _should_skip_sync(str(relative)):
+                continue
+
+            project_file = project_path / relative
+
+            # Only update existing files (new files handled by cleanup_nested)
+            if not project_file.exists():
+                continue
+
+            # Compare file contents
+            try:
+                template_content = template_file.read_bytes()
+                project_content = project_file.read_bytes()
+
+                if template_content != project_content:
+                    # Update project file with template version
+                    project_file.write_bytes(template_content)
+                    files_updated.append(str(relative))
+                    verbose_print(f"   Synced: {relative}")
+            except OSError as e:
+                verbose_print(f"   Warning: Could not sync {relative}: {e}")
+
+    return files_updated
+
+
+def _should_skip_sync(relative_path: str) -> bool:
+    """Check if a file should be skipped during template sync."""
+    skip_patterns = [
+        ".copier-answers.yml",
+        ".env",
+        ".python-version",
+        ".venv/",
+        "__pycache__/",
+        ".git/",
+        "*.pyc",
+    ]
+
+    for pattern in skip_patterns:
+        if pattern.endswith("/"):
+            if relative_path.startswith(pattern) or f"/{pattern}" in relative_path:
+                return True
+        elif pattern.startswith("*"):
+            if relative_path.endswith(pattern[1:]):
+                return True
+        elif relative_path == pattern:
+            return True
+
+    return False

copier.yml

@@ -6,7 +6,7 @@
 # - Update support
 
 _min_copier_version: "9.0.0"
-_version: "0.5.2-rc4"
+_version: "0.5.2-rc5"
 
 # 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-rc4"
+version = "0.5.2-rc5"
 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_template_cleanup.py

@@ -8,7 +8,11 @@
 from pathlib import Path
 from unittest.mock import patch
 
-from aegis.core.template_cleanup import cleanup_nested_project_directory
+from aegis.core.template_cleanup import (
+    _should_skip_sync,
+    cleanup_nested_project_directory,
+    sync_template_changes,
+)
 
 
 class TestCleanupNestedProjectDirectory:
@@ -346,3 +350,185 @@ def test_full_update_flow_with_ai_enabled(self, tmp_path: Path) -> None:
         assert (tmp_path / "app" / "services" / "ai" / "agent.py").exists(), (
             "AI agent.py should be kept"
         )
+
+
+class TestShouldSkipSync:
+    """Test _should_skip_sync helper function."""
+
+    def test_skips_copier_answers(self) -> None:
+        """Test that .copier-answers.yml is skipped."""
+        assert _should_skip_sync(".copier-answers.yml") is True
+
+    def test_skips_env_file(self) -> None:
+        """Test that .env is skipped."""
+        assert _should_skip_sync(".env") is True
+
+    def test_skips_python_version(self) -> None:
+        """Test that .python-version is skipped."""
+        assert _should_skip_sync(".python-version") is True
+
+    def test_skips_venv_directory(self) -> None:
+        """Test that .venv/ files are skipped."""
+        assert _should_skip_sync(".venv/lib/python3.11/site-packages/foo.py") is True
+
+    def test_skips_pycache(self) -> None:
+        """Test that __pycache__/ files are skipped."""
+        assert _should_skip_sync("__pycache__/module.cpython-311.pyc") is True
+        assert _should_skip_sync("app/__pycache__/foo.pyc") is True
+
+    def test_skips_pyc_files(self) -> None:
+        """Test that .pyc files are skipped."""
+        assert _should_skip_sync("module.pyc") is True
+        assert _should_skip_sync("app/services/ai/agent.pyc") is True
+
+    def test_does_not_skip_regular_files(self) -> None:
+        """Test that regular Python files are not skipped."""
+        assert _should_skip_sync("app/__init__.py") is False
+        assert _should_skip_sync("app/services/ai/agent.py") is False
+        assert _should_skip_sync("pyproject.toml") is False
+        assert _should_skip_sync("app/components/frontend/theme.py") is False
+
+
+class TestSyncTemplateChanges:
+    """Test sync_template_changes function."""
+
+    def test_empty_project_slug_returns_empty(self, tmp_path: Path) -> None:
+        """Test that empty list is returned when project_slug is empty."""
+        answers: dict[str, str] = {"project_slug": ""}
+        result = sync_template_changes(tmp_path, answers, "gh:test/repo", "v1.0.0")
+        assert result == []
+
+    def test_syncs_differing_files(self, tmp_path: Path) -> None:
+        """Test that files differing from template are synced."""
+        project_slug = "my-project"
+        answers = {"project_slug": project_slug}
+
+        # Create project file with old content
+        project_file = tmp_path / "app" / "config.py"
+        project_file.parent.mkdir(parents=True)
+        project_file.write_text("# old config")
+
+        def mock_run_copy(
+            src_path: str,
+            dst_path: str,
+            data: dict,
+            defaults: bool,
+            overwrite: bool,
+            unsafe: bool,
+            vcs_ref: str,
+            quiet: bool,
+        ) -> None:
+            """Mock run_copy to create rendered template."""
+            rendered_dir = Path(dst_path) / project_slug / "app"
+            rendered_dir.mkdir(parents=True)
+            (rendered_dir / "config.py").write_text("# new config from template")
+
+        with patch("copier.run_copy", side_effect=mock_run_copy):
+            result = sync_template_changes(tmp_path, answers, "gh:test/repo", "v1.0.0")
+
+        # File should be synced
+        assert "app/config.py" in result
+        assert project_file.read_text() == "# new config from template"
+
+    def test_skips_identical_files(self, tmp_path: Path) -> None:
+        """Test that identical files are not synced."""
+        project_slug = "my-project"
+        answers = {"project_slug": project_slug}
+
+        # Create project file with same content as template
+        project_file = tmp_path / "app" / "config.py"
+        project_file.parent.mkdir(parents=True)
+        project_file.write_text("# same content")
+
+        def mock_run_copy(
+            src_path: str,
+            dst_path: str,
+            data: dict,
+            defaults: bool,
+            overwrite: bool,
+            unsafe: bool,
+            vcs_ref: str,
+            quiet: bool,
+        ) -> None:
+            """Mock run_copy to create rendered template with same content."""
+            rendered_dir = Path(dst_path) / project_slug / "app"
+            rendered_dir.mkdir(parents=True)
+            (rendered_dir / "config.py").write_text("# same content")
+
+        with patch("copier.run_copy", side_effect=mock_run_copy):
+            result = sync_template_changes(tmp_path, answers, "gh:test/repo", "v1.0.0")
+
+        # File should NOT be synced (identical)
+        assert result == []
+
+    def test_skips_nonexistent_project_files(self, tmp_path: Path) -> None:
+        """Test that new files in template are skipped (handled by cleanup_nested)."""
+        project_slug = "my-project"
+        answers = {"project_slug": project_slug}
+
+        # Don't create project file - it doesn't exist
+
+        def mock_run_copy(
+            src_path: str,
+            dst_path: str,
+            data: dict,
+            defaults: bool,
+            overwrite: bool,
+            unsafe: bool,
+            vcs_ref: str,
+            quiet: bool,
+        ) -> None:
+            """Mock run_copy to create new file in template."""
+            rendered_dir = Path(dst_path) / project_slug / "app"
+            rendered_dir.mkdir(parents=True)
+            (rendered_dir / "new_file.py").write_text("# new file")
+
+        with patch("copier.run_copy", side_effect=mock_run_copy):
+            result = sync_template_changes(tmp_path, answers, "gh:test/repo", "v1.0.0")
+
+        # New file should NOT be synced (doesn't exist in project)
+        assert result == []
+        assert not (tmp_path / "app" / "new_file.py").exists()
+
+    def test_skips_files_matching_skip_patterns(self, tmp_path: Path) -> None:
+        """Test that files matching skip patterns are not synced."""
+        project_slug = "my-project"
+        answers = {"project_slug": project_slug}
+
+        # Create .env file in project
+        env_file = tmp_path / ".env"
+        env_file.write_text("SECRET=old_value")
+
+        def mock_run_copy(
+            src_path: str,
+            dst_path: str,
+            data: dict,
+            defaults: bool,
+            overwrite: bool,
+            unsafe: bool,
+            vcs_ref: str,
+            quiet: bool,
+        ) -> None:
+            """Mock run_copy to create .env in template."""
+            rendered_dir = Path(dst_path) / project_slug
+            rendered_dir.mkdir(parents=True)
+            (rendered_dir / ".env").write_text("SECRET=new_value")
+
+        with patch("copier.run_copy", side_effect=mock_run_copy):
+            result = sync_template_changes(tmp_path, answers, "gh:test/repo", "v1.0.0")
+
+        # .env should NOT be synced (in skip list)
+        assert result == []
+        assert env_file.read_text() == "SECRET=old_value"
+
+    def test_handles_render_failure(self, tmp_path: Path) -> None:
+        """Test that render failure returns empty list."""
+        answers = {"project_slug": "my-project"}
+
+        with patch(
+            "copier.run_copy",
+            side_effect=Exception("Render failed"),
+        ):
+            result = sync_template_changes(tmp_path, answers, "gh:test/repo", "v1.0.0")
+
+        assert result == []