aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/core/copier_updater.py

@@ -0,0 +1,475 @@
+"""
+Experimental Copier-based updater using git-aware template at repo root.
+
+This module provides an alternative to the manual updater by using Copier's
+native update mechanism with a copier.yml at the repository root.
+"""
+
+import subprocess
+from pathlib import Path
+
+from copier import run_update
+from packaging.version import parse
+from pydantic import BaseModel, Field
+
+from aegis.core.copier_manager import load_copier_answers
+from aegis.core.post_gen_tasks import run_post_generation_tasks
+
+
+class CopierUpdateResult(BaseModel):
+    """Result of a Copier update operation."""
+
+    success: bool = Field(description="Whether the operation succeeded")
+    method: str = Field(default="copier-native", description="Update method used")
+    error_message: str | None = Field(
+        default=None, description="Error message if operation failed"
+    )
+    files_modified: list[str] = Field(
+        default_factory=list, description="Files that were modified"
+    )
+
+
+def get_template_root() -> Path:
+    """
+    Get path to aegis-stack repository root (where copier.yml lives).
+
+    Returns:
+        Path to aegis-stack root directory
+    """
+    # This file is at: aegis-stack/aegis/core/copier_updater.py
+    # We want: aegis-stack/ (2 levels up)
+    return Path(__file__).parents[2]
+
+
+def update_with_copier_native(
+    project_path: Path,
+    components_to_add: list[str],
+    scheduler_backend: str = "memory",
+) -> CopierUpdateResult:
+    """
+    EXPERIMENTAL: Use Copier's native update with git root template.
+
+    This approach uses the copier.yml at aegis-stack repo root which
+    includes _subdirectory setting. This allows Copier to recognize the
+    template as git-tracked and use proper merge conflict handling.
+
+    Args:
+        project_path: Path to the existing project directory
+        components_to_add: List of component names to add
+        scheduler_backend: Backend to use for scheduler ("memory" or "sqlite")
+
+    Returns:
+        CopierUpdateResult with success status
+
+    Note:
+        This is experimental. Falls back to manual updater if it fails.
+    """
+    try:
+        # Get template root (aegis-stack/, not aegis/templates/...)
+        template_root = get_template_root()
+
+        # Build update data for Copier
+        update_data: dict[str, bool | str] = {}
+
+        for component in components_to_add:
+            include_key = f"include_{component}"
+            update_data[include_key] = True
+
+        # Add scheduler backend configuration if adding scheduler
+        if "scheduler" in components_to_add:
+            update_data["scheduler_backend"] = scheduler_backend
+            update_data["scheduler_with_persistence"] = scheduler_backend == "sqlite"
+
+        # CRITICAL: Manually update .copier-answers.yml BEFORE running copier update
+        # The `data` parameter in run_update() doesn't actually update existing answers
+        # We must edit the file directly, then Copier detects the change and regenerates
+        answers = load_copier_answers(project_path)
+        answers.update(update_data)
+
+        # Save updated answers
+        import yaml
+
+        answers_file = project_path / ".copier-answers.yml"
+        with open(answers_file, "w") as f:
+            yaml.safe_dump(answers, f, default_flow_style=False, sort_keys=False)
+
+        # Commit the updated answers (Copier requires clean repo)
+        import subprocess
+
+        try:
+            subprocess.run(
+                ["git", "add", ".copier-answers.yml"],
+                cwd=project_path,
+                check=True,
+                capture_output=True,
+            )
+            subprocess.run(
+                [
+                    "git",
+                    "commit",
+                    "-m",
+                    f"Enable components: {', '.join(components_to_add)}",
+                ],
+                cwd=project_path,
+                check=True,
+                capture_output=True,
+            )
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to commit .copier-answers.yml changes: {e}")
+
+        # Run Copier update
+        # Copier will detect the changed answers and regenerate files accordingly
+        # Copier will:
+        # 1. Use repo root as template (where .git exists)
+        # 2. _subdirectory setting in copier.yml points to actual template content
+        # 3. Detect template is git-tracked (finds .git at aegis-stack/)
+        # 4. Detect changed answers in .copier-answers.yml (we just committed them)
+        # 5. Use git diff to merge changes
+        # 6. Handle conflicts with .rej files or inline markers
+        # NOTE: _tasks removed from copier.yml - we run them ourselves below
+        run_update(
+            dst_path=str(project_path),
+            src_path=str(template_root),  # Point to repo root, not subdirectory
+            defaults=True,  # Use existing answers as defaults
+            overwrite=True,  # Allow overwriting files
+            conflict="rej",  # Create .rej files for conflicts
+            unsafe=False,  # No tasks in copier.yml anymore - we run them ourselves
+            vcs_ref="HEAD",  # Use latest template version
+        )
+
+        # CRITICAL: Copy service-specific files for newly-added services
+        # Copier can only re-render existing files - it cannot copy new directories
+        # that were excluded during initial generation
+        answers = load_copier_answers(project_path)
+
+        # Check for services in components_to_add (they start with 'include_')
+        # Service names: auth, ai
+        service_names = {"auth", "ai"}
+        newly_added_services = [
+            svc for svc in service_names if f"include_{svc}" in update_data
+        ]
+
+        if newly_added_services:
+            from aegis.core.post_gen_tasks import copy_service_files
+
+            # Template content is at: template_root/aegis/templates/copier-aegis-project/
+            template_path = (
+                template_root / "aegis" / "templates" / "copier-aegis-project"
+            )
+
+            for service_name in newly_added_services:
+                copy_service_files(project_path, service_name, template_path)
+
+        # Run post-generation tasks with explicit working directory control
+        # This ensures consistent behavior with initial generation
+        include_auth = answers.get("include_auth", False)
+
+        # Run shared post-generation tasks
+        run_post_generation_tasks(project_path, include_auth=include_auth)
+
+        return CopierUpdateResult(
+            success=True,
+            method="copier-native",
+            files_modified=[],  # Copier doesn't provide this info easily
+        )
+
+    except Exception as e:
+        return CopierUpdateResult(
+            success=False, method="copier-native", error_message=str(e)
+        )
+
+
+# Version Management Functions
+
+
+def get_current_template_commit(project_path: Path) -> str | None:
+    """
+    Get the git commit hash of the template used to generate the project.
+
+    Args:
+        project_path: Path to the project directory
+
+    Returns:
+        Commit hash string or None if not found
+    """
+    try:
+        answers = load_copier_answers(project_path)
+        commit_hash = answers.get("_commit")
+        if commit_hash and commit_hash != "None":
+            return commit_hash
+        return None
+    except Exception:
+        return None
+
+
+def get_available_versions(template_root: Path | None = None) -> list[str]:
+    """
+    Get list of available template versions from git tags.
+
+    Args:
+        template_root: Path to template repository (default: auto-detect)
+
+    Returns:
+        List of version strings sorted by PEP 440 (newest first)
+    """
+    if template_root is None:
+        template_root = get_template_root()
+
+    try:
+        result = subprocess.run(
+            ["git", "tag", "--list", "v*"],
+            cwd=template_root,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        # Parse tags (remove 'v' prefix and filter valid versions)
+        versions = []
+        for tag in result.stdout.strip().split("\n"):
+            if tag.startswith("v"):
+                version_str = tag[1:]  # Remove 'v' prefix
+                try:
+                    parse(version_str)  # Validate version
+                    versions.append(version_str)
+                except Exception:
+                    continue
+
+        # Sort by PEP 440 (newest first)
+        versions.sort(key=lambda v: parse(v), reverse=True)
+        return versions
+
+    except Exception:
+        return []
+
+
+def get_latest_version(template_root: Path | None = None) -> str | None:
+    """
+    Get the latest template version from git tags.
+
+    Args:
+        template_root: Path to template repository (default: auto-detect)
+
+    Returns:
+        Latest version string or None if no versions found
+    """
+    versions = get_available_versions(template_root)
+    return versions[0] if versions else None
+
+
+def resolve_ref_to_commit(ref: str, repo_path: Path) -> str | None:
+    """
+    Resolve a git reference (HEAD, branch, tag, commit) to full commit SHA.
+
+    Args:
+        ref: Git reference (HEAD, branch name, tag, or commit hash)
+        repo_path: Path to git repository
+
+    Returns:
+        Full commit SHA or None if resolution fails
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", ref],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError:
+        return None
+
+
+def resolve_version_to_ref(
+    version: str | None, template_root: Path | None = None
+) -> str:
+    """
+    Resolve a version string to a git reference.
+
+    Args:
+        version: Version string ("latest", "0.2.0", commit hash, or None)
+        template_root: Path to template repository (default: auto-detect)
+
+    Returns:
+        Git reference string (tag name, commit hash, or "HEAD")
+    """
+    if template_root is None:
+        template_root = get_template_root()
+
+    # None or "latest" -> use latest version tag
+    if not version or version == "latest":
+        latest = get_latest_version(template_root)
+        if latest:
+            return f"v{latest}"
+        return "HEAD"
+
+    # Check if it's a commit hash (40 hex characters)
+    if len(version) == 40 and all(c in "0123456789abcdef" for c in version.lower()):
+        return version
+
+    # Check if it looks like a version number (add 'v' prefix)
+    try:
+        parse(version)
+        # Valid version number - check if tag exists
+        tag_name = f"v{version}"
+        result = subprocess.run(
+            ["git", "rev-parse", "--verify", f"refs/tags/{tag_name}"],
+            cwd=template_root,
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            return tag_name
+    except Exception:
+        pass
+
+    # Fall back to using the version string as-is (might be a branch name)
+    return version
+
+
+def validate_clean_git_tree(project_path: Path) -> tuple[bool, str]:
+    """
+    Check if the project's git working tree is clean.
+
+    Args:
+        project_path: Path to project directory
+
+    Returns:
+        Tuple of (is_clean: bool, message: str)
+    """
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=project_path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        if result.stdout.strip():
+            return False, "Git tree has uncommitted changes"
+
+        return True, "Git tree is clean"
+
+    except subprocess.CalledProcessError as e:
+        return False, f"Failed to check git status: {e}"
+    except Exception as e:
+        return False, f"Error checking git status: {e}"
+
+
+def get_changelog(from_ref: str, to_ref: str, template_root: Path | None = None) -> str:
+    """
+    Get changelog between two git references.
+
+    Args:
+        from_ref: Starting git reference (commit, tag, or branch)
+        to_ref: Ending git reference
+        template_root: Path to template repository (default: auto-detect)
+
+    Returns:
+        Formatted changelog string
+    """
+    if template_root is None:
+        template_root = get_template_root()
+
+    try:
+        # Get commit log between refs
+        result = subprocess.run(
+            [
+                "git",
+                "log",
+                "--oneline",
+                "--no-merges",
+                "--pretty=format:%s",
+                f"{from_ref}..{to_ref}",
+            ],
+            cwd=template_root,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        if not result.stdout.strip():
+            return "No changes"
+
+        # Parse commits and categorize
+        commits = result.stdout.strip().split("\n")
+        features = []
+        fixes = []
+        breaking = []
+        other = []
+
+        for commit in commits:
+            commit_lower = commit.lower()
+            if "breaking:" in commit_lower or "breaking change" in commit_lower:
+                breaking.append(commit)
+            elif commit.startswith("feat:") or commit.startswith("feature:"):
+                features.append(commit)
+            elif commit.startswith("fix:"):
+                fixes.append(commit)
+            else:
+                other.append(commit)
+
+        # Format changelog
+        lines = []
+
+        if breaking:
+            lines.append("⚠️  Breaking Changes:")
+            for commit in breaking:
+                lines.append(f"  • {commit}")
+            lines.append("")
+
+        if features:
+            lines.append("✨ New Features:")
+            for commit in features:
+                lines.append(f"  • {commit}")
+            lines.append("")
+
+        if fixes:
+            lines.append("🐛 Bug Fixes:")
+            for commit in fixes:
+                lines.append(f"  • {commit}")
+            lines.append("")
+
+        if other:
+            lines.append("📝 Other Changes:")
+            for commit in other:
+                lines.append(f"  • {commit}")
+
+        return "\n".join(lines).strip()
+
+    except Exception as e:
+        return f"Error generating changelog: {e}"
+
+
+def get_commit_for_version(
+    version: str, template_root: Path | None = None
+) -> str | None:
+    """
+    Get the git commit hash for a version tag.
+
+    Args:
+        version: Version string (with or without 'v' prefix)
+        template_root: Path to template repository (default: auto-detect)
+
+    Returns:
+        Commit hash or None if tag not found
+    """
+    if template_root is None:
+        template_root = get_template_root()
+
+    # Ensure version has 'v' prefix
+    tag_name = version if version.startswith("v") else f"v{version}"
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-list", "-n", "1", tag_name],
+            cwd=template_root,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return None

aegis/core/dependency_resolver.py

@@ -0,0 +1,119 @@
+"""
+Component dependency resolution for Aegis Stack.
+
+This module handles dependency resolution, validation, and recommendations
+for component selection during project generation.
+"""
+
+from .components import COMPONENTS
+
+
+class DependencyResolver:
+    """Handles component dependency resolution and validation."""
+
+    @staticmethod
+    def resolve_dependencies(selected_components: list[str]) -> list[str]:
+        """
+        Resolve all dependencies and return final component list.
+
+        Args:
+            selected_components: List of component names selected by user
+
+        Returns:
+            Complete list of components including dependencies
+
+        Raises:
+            ValueError: If any selected components are invalid
+        """
+        # Validate all components first
+        errors = DependencyResolver.validate_components(selected_components)
+        if errors:
+            raise ValueError(f"Invalid components: {'; '.join(errors)}")
+
+        resolved = set(selected_components)
+
+        # Resolve hard dependencies recursively
+        while True:
+            before_size = len(resolved)
+            for component_name in list(resolved):
+                if component_name not in COMPONENTS:
+                    continue
+
+                component = COMPONENTS[component_name]
+                if component.requires:
+                    resolved.update(component.requires)
+
+            if len(resolved) == before_size:
+                break  # No new dependencies added
+
+        return sorted(resolved)
+
+    @staticmethod
+    def validate_components(components: list[str]) -> list[str]:
+        """
+        Validate component selection and return errors.
+
+        Args:
+            components: List of component names to validate
+
+        Returns:
+            List of error messages (empty if valid)
+        """
+        errors = []
+
+        for component in components:
+            if component not in COMPONENTS:
+                errors.append(f"Unknown component: {component}")
+                continue
+
+            spec = COMPONENTS[component]
+
+            # Check conflicts
+            if spec.conflicts:
+                for conflict in spec.conflicts:
+                    if conflict in components:
+                        errors.append(
+                            f"Component '{component}' conflicts with '{conflict}'"
+                        )
+
+        return errors
+
+    @staticmethod
+    def get_recommendations(selected_components: list[str]) -> list[str]:
+        """
+        Get recommended components based on selection.
+
+        Args:
+            selected_components: List of already selected components
+
+        Returns:
+            List of recommended component names not already selected
+        """
+        recommendations = set()
+
+        for component_name in selected_components:
+            if component_name not in COMPONENTS:
+                continue
+
+            component = COMPONENTS[component_name]
+            if component.recommends:
+                for rec in component.recommends:
+                    if rec not in selected_components:
+                        recommendations.add(rec)
+
+        return sorted(recommendations)
+
+    @staticmethod
+    def get_missing_dependencies(selected_components: list[str]) -> list[str]:
+        """
+        Get dependencies that would be auto-added.
+
+        Args:
+            selected_components: List of user-selected components
+
+        Returns:
+            List of dependencies that would be automatically added
+        """
+        resolved = DependencyResolver.resolve_dependencies(selected_components)
+        auto_added = set(resolved) - set(selected_components)
+        return sorted(auto_added)