moai-adk 0.3.0__py3-none-any.whl

moai_adk/core/project/phase_executor.py

@@ -0,0 +1,297 @@
+# @CODE:INIT-003:PHASE | SPEC: .moai/specs/SPEC-INIT-003/spec.md | TEST: tests/unit/test_init_reinit.py
+"""Phase-based installation executor (SPEC-INIT-003 v0.3.0)
+
+Runs the project initialization across five phases:
+- Phase 1: Preparation (create backup at .moai-backups/{timestamp}/, keep only latest)
+- Phase 2: Directory (build directory structure)
+- Phase 3: Resource (copy templates while preserving user content)
+- Phase 4: Configuration (generate configuration files)
+- Phase 5: Validation (verify and finalize)
+"""
+
+import json
+import shutil
+import subprocess
+from collections.abc import Callable
+from pathlib import Path
+
+from rich.console import Console
+
+from moai_adk import __version__
+from moai_adk.core.project.backup_utils import (
+    generate_backup_dir_name,
+    get_backup_targets,
+    has_any_moai_files,
+    is_protected_path,
+)
+from moai_adk.core.project.validator import ProjectValidator
+
+console = Console()
+
+# Progress callback type alias
+ProgressCallback = Callable[[str, int, int], None]
+
+
+class PhaseExecutor:
+    """Execute the installation across the five phases.
+
+    Phases:
+    1. Preparation: Back up and verify the system.
+    2. Directory: Create the directory structure.
+    3. Resource: Copy template resources.
+    4. Configuration: Generate configuration files.
+    5. Validation: Perform final checks.
+    """
+
+    # Required directory structure
+    REQUIRED_DIRECTORIES = [
+        ".moai/",
+        ".moai/project/",
+        ".moai/specs/",
+        ".moai/reports/",
+        ".moai/memory/",
+        ".claude/",
+        ".claude/logs/",
+    ]
+
+    def __init__(self, validator: ProjectValidator) -> None:
+        """Initialize the executor.
+
+        Args:
+            validator: Project validation helper.
+        """
+        self.validator = validator
+        self.total_phases = 5
+        self.current_phase = 0
+
+    def execute_preparation_phase(
+        self,
+        project_path: Path,
+        backup_enabled: bool = True,
+        progress_callback: ProgressCallback | None = None,
+    ) -> None:
+        """Phase 1: preparation and backup.
+
+        Args:
+            project_path: Project path.
+            backup_enabled: Whether backups are enabled.
+            progress_callback: Optional progress callback.
+        """
+        self.current_phase = 1
+        self._report_progress(
+            "Phase 1: Preparation and backup...", progress_callback
+        )
+
+        # Validate system requirements
+        self.validator.validate_system_requirements()
+
+        # Verify the project path
+        self.validator.validate_project_path(project_path)
+
+        # Create a backup when needed
+        if backup_enabled and has_any_moai_files(project_path):
+            self._create_backup(project_path)
+
+    def execute_directory_phase(
+        self,
+        project_path: Path,
+        progress_callback: ProgressCallback | None = None,
+    ) -> None:
+        """Phase 2: create directories.
+
+        Args:
+            project_path: Project path.
+            progress_callback: Optional progress callback.
+        """
+        self.current_phase = 2
+        self._report_progress(
+            "Phase 2: Creating directory structure...", progress_callback
+        )
+
+        for directory in self.REQUIRED_DIRECTORIES:
+            dir_path = project_path / directory
+            dir_path.mkdir(parents=True, exist_ok=True)
+
+    def execute_resource_phase(
+        self,
+        project_path: Path,
+        progress_callback: ProgressCallback | None = None,
+    ) -> list[str]:
+        """Phase 3: install resources.
+
+        Args:
+            project_path: Project path.
+            progress_callback: Optional progress callback.
+
+        Returns:
+            List of created files or directories.
+        """
+        self.current_phase = 3
+        self._report_progress(
+            "Phase 3: Installing resources...", progress_callback
+        )
+
+        # Copy resources via TemplateProcessor in silent mode
+        from moai_adk.core.template import TemplateProcessor
+
+        processor = TemplateProcessor(project_path)
+        processor.copy_templates(backup=False, silent=True)  # Avoid progress bar conflicts
+
+        # Return a simplified list of generated assets
+        return [
+            ".claude/",
+            ".moai/",
+            "CLAUDE.md",
+            ".gitignore",
+        ]
+
+    def execute_configuration_phase(
+        self,
+        project_path: Path,
+        config: dict[str, str],
+        progress_callback: ProgressCallback | None = None,
+    ) -> list[str]:
+        """Phase 4: generate configuration.
+
+        Args:
+            project_path: Project path.
+            config: Configuration dictionary.
+            progress_callback: Optional progress callback.
+
+        Returns:
+            List of created files.
+        """
+        self.current_phase = 4
+        self._report_progress(
+            "Phase 4: Generating configurations...", progress_callback
+        )
+
+        # Attach version metadata (v0.3.1+)
+        config["moai_adk_version"] = __version__
+        config["optimized"] = False  # Default value
+
+        # Write config.json
+        config_path = project_path / ".moai" / "config.json"
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+
+        return [str(config_path)]
+
+    def execute_validation_phase(
+        self,
+        project_path: Path,
+        mode: str = "personal",
+        progress_callback: ProgressCallback | None = None,
+    ) -> None:
+        """Phase 5: validation and wrap-up.
+
+        Args:
+            project_path: Project path.
+            mode: Project mode (personal/team).
+            progress_callback: Optional progress callback.
+        """
+        self.current_phase = 5
+        self._report_progress(
+            "Phase 5: Validation and finalization...", progress_callback
+        )
+
+        # Validate installation results
+        self.validator.validate_installation(project_path)
+
+        # Initialize Git for team mode
+        if mode == "team":
+            self._initialize_git(project_path)
+
+    def _create_backup(self, project_path: Path) -> None:
+        """Create a selective backup (v0.3.0).
+
+        Keep only the latest backup in .moai-backups/{timestamp}/.
+
+        Args:
+            project_path: Project path.
+        """
+        # Define backup directory
+        backups_dir = project_path / ".moai-backups"
+
+        # Remove all existing backups (keep only latest)
+        if backups_dir.exists():
+            for item in backups_dir.iterdir():
+                if item.is_dir():
+                    shutil.rmtree(item)
+
+        # Create new backup directory (.moai-backups/{timestamp}/)
+        timestamp = generate_backup_dir_name()
+        backup_path = backups_dir / timestamp
+        backup_path.mkdir(parents=True, exist_ok=True)
+
+        # Collect backup targets
+        targets = get_backup_targets(project_path)
+        backed_up_files: list[str] = []
+
+        # Execute the backup
+        for target in targets:
+            src_path = project_path / target
+            dst_path = backup_path / target
+
+            if src_path.is_dir():
+                self._copy_directory_selective(src_path, dst_path)
+                backed_up_files.append(f"{target}/")
+            else:
+                dst_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(src_path, dst_path)
+                backed_up_files.append(target)
+
+        # Avoid additional console messages to prevent progress bar conflicts
+
+    def _copy_directory_selective(self, src: Path, dst: Path) -> None:
+        """Copy a directory while skipping protected paths.
+
+        Args:
+            src: Source directory.
+            dst: Destination directory.
+        """
+        dst.mkdir(parents=True, exist_ok=True)
+
+        for item in src.rglob("*"):
+            rel_path = item.relative_to(src)
+
+            # Skip protected paths
+            if is_protected_path(rel_path):
+                continue
+
+            dst_item = dst / rel_path
+            if item.is_file():
+                dst_item.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(item, dst_item)
+            elif item.is_dir():
+                dst_item.mkdir(parents=True, exist_ok=True)
+
+    def _initialize_git(self, project_path: Path) -> None:
+        """Initialize a Git repository.
+
+        Args:
+            project_path: Project path.
+        """
+        try:
+            subprocess.run(
+                ["git", "init"],
+                cwd=project_path,
+                check=True,
+                capture_output=True,
+            )
+            # Intentionally avoid printing to keep progress output clean
+        except subprocess.CalledProcessError:
+            # Only log on error; failures are non-fatal
+            pass
+
+    def _report_progress(
+        self, message: str, callback: ProgressCallback | None
+    ) -> None:
+        """Report progress.
+
+        Args:
+            message: Progress message.
+            callback: Callback function.
+        """
+        if callback:
+            callback(message, self.current_phase, self.total_phases)

moai_adk/core/project/validator.py

@@ -0,0 +1,118 @@
+# @CODE:CORE-PROJECT-003 | SPEC: SPEC-CORE-PROJECT-001.md
+"""Project initialization validation module.
+
+Validates system requirements and installation results.
+"""
+
+import shutil
+from pathlib import Path
+
+
+class ValidationError(Exception):
+    """Raised when validation fails."""
+
+    pass
+
+
+class ProjectValidator:
+    """Validate project initialization."""
+
+    # Required directory structure
+    REQUIRED_DIRECTORIES = [
+        ".moai/",
+        ".moai/project/",
+        ".moai/specs/",
+        ".moai/memory/",
+        ".claude/",
+    ]
+
+    # Required files
+    REQUIRED_FILES = [
+        ".moai/config.json",
+        "CLAUDE.md",
+    ]
+
+    def validate_system_requirements(self) -> None:
+        """Verify system requirements.
+
+        Raises:
+            ValidationError: Raised when requirements are not satisfied.
+        """
+        # Ensure Git is installed
+        if not shutil.which("git"):
+            raise ValidationError("Git is not installed")
+
+        # Check Python version (3.10+)
+        import sys
+
+        if sys.version_info < (3, 10):
+            raise ValidationError(
+                f"Python 3.10+ required (current: {sys.version_info.major}.{sys.version_info.minor})"
+            )
+
+    def validate_project_path(self, project_path: Path) -> None:
+        """Verify the project path.
+
+        Args:
+            project_path: Project path.
+
+        Raises:
+            ValidationError: Raised when the path is invalid.
+        """
+        # Must be an absolute path
+        if not project_path.is_absolute():
+            raise ValidationError(f"Project path must be absolute: {project_path}")
+
+        # Parent directory must exist
+        if not project_path.parent.exists():
+            raise ValidationError(f"Parent directory does not exist: {project_path.parent}")
+
+        # Prevent initialization inside the MoAI-ADK package
+        if self._is_inside_moai_package(project_path):
+            raise ValidationError(
+                "Cannot initialize inside MoAI-ADK package directory"
+            )
+
+    def validate_installation(self, project_path: Path) -> None:
+        """Validate installation results.
+
+        Args:
+            project_path: Project path.
+
+        Raises:
+            ValidationError: Raised when installation was incomplete.
+        """
+        # Verify required directories
+        for directory in self.REQUIRED_DIRECTORIES:
+            dir_path = project_path / directory
+            if not dir_path.exists():
+                raise ValidationError(f"Required directory not found: {directory}")
+
+        # Verify required files
+        for file in self.REQUIRED_FILES:
+            file_path = project_path / file
+            if not file_path.exists():
+                raise ValidationError(f"Required file not found: {file}")
+
+    def _is_inside_moai_package(self, project_path: Path) -> bool:
+        """Determine whether the path is inside the MoAI-ADK package.
+
+        Args:
+            project_path: Path to check.
+
+        Returns:
+            True when the path resides within the package.
+        """
+        # The package root contains a pyproject.toml referencing moai-adk
+        current = project_path.resolve()
+        while current != current.parent:
+            pyproject = current / "pyproject.toml"
+            if pyproject.exists():
+                try:
+                    content = pyproject.read_text(encoding="utf-8")
+                    if "name = \"moai-adk\"" in content or 'name = "moai-adk"' in content:
+                        return True
+                except Exception:
+                    pass
+            current = current.parent
+        return False

moai_adk/core/quality/__init__.py

@@ -0,0 +1,6 @@
+# @CODE:TRUST-001 | SPEC: SPEC-TRUST-001.md | TEST: tests/unit/core/quality/
+"""TRUST 원칙 자동 검증 시스템"""
+
+from moai_adk.core.quality.trust_checker import TrustChecker
+
+__all__ = ["TrustChecker"]