moai-adk 0.3.0__py3-none-any.whl

moai_adk/core/project/checker.py

@@ -0,0 +1,302 @@
+# @CODE:CLI-001 | SPEC: SPEC-CLI-001.md | TEST: tests/unit/test_cli_commands.py
+"""System requirements validation module.
+
+Checks whether required and optional tools are installed.
+"""
+
+import platform
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+class SystemChecker:
+    """Validate system requirements."""
+
+    REQUIRED_TOOLS: dict[str, str] = {
+        "git": "git --version",
+        "python": "python3 --version",
+    }
+
+    OPTIONAL_TOOLS: dict[str, str] = {
+        "gh": "gh --version",
+        "docker": "docker --version",
+    }
+
+    # @CODE:CLI-001:DATA - Language toolchain mapping (20 languages)
+    LANGUAGE_TOOLS: dict[str, dict[str, list[str]]] = {
+        "python": {
+            "required": ["python3", "pip"],
+            "recommended": ["pytest", "mypy", "ruff"],
+            "optional": ["black", "pylint"],
+        },
+        "typescript": {
+            "required": ["node", "npm"],
+            "recommended": ["vitest", "biome"],
+            "optional": ["typescript", "eslint"],
+        },
+        "javascript": {
+            "required": ["node", "npm"],
+            "recommended": ["jest", "eslint"],
+            "optional": ["prettier", "webpack"],
+        },
+        "java": {
+            "required": ["java", "javac"],
+            "recommended": ["maven", "gradle"],
+            "optional": ["junit", "checkstyle"],
+        },
+        "go": {
+            "required": ["go"],
+            "recommended": ["golangci-lint", "gofmt"],
+            "optional": ["delve", "gopls"],
+        },
+        "rust": {
+            "required": ["rustc", "cargo"],
+            "recommended": ["rustfmt", "clippy"],
+            "optional": ["rust-analyzer", "cargo-audit"],
+        },
+        "dart": {
+            "required": ["dart"],
+            "recommended": ["flutter", "dart_test"],
+            "optional": ["dartfmt", "dartanalyzer"],
+        },
+        "swift": {
+            "required": ["swift", "swiftc"],
+            "recommended": ["xcrun", "swift-format"],
+            "optional": ["swiftlint", "sourcekit-lsp"],
+        },
+        "kotlin": {
+            "required": ["kotlin", "kotlinc"],
+            "recommended": ["gradle", "ktlint"],
+            "optional": ["detekt", "kotlin-language-server"],
+        },
+        "csharp": {
+            "required": ["dotnet"],
+            "recommended": ["msbuild", "nuget"],
+            "optional": ["csharpier", "roslyn"],
+        },
+        "php": {
+            "required": ["php"],
+            "recommended": ["composer", "phpunit"],
+            "optional": ["psalm", "phpstan"],
+        },
+        "ruby": {
+            "required": ["ruby", "gem"],
+            "recommended": ["bundler", "rspec"],
+            "optional": ["rubocop", "solargraph"],
+        },
+        "elixir": {
+            "required": ["elixir", "mix"],
+            "recommended": ["hex", "dialyzer"],
+            "optional": ["credo", "ex_unit"],
+        },
+        "scala": {
+            "required": ["scala", "scalac"],
+            "recommended": ["sbt", "scalatest"],
+            "optional": ["scalafmt", "metals"],
+        },
+        "clojure": {
+            "required": ["clojure", "clj"],
+            "recommended": ["leiningen", "clojure.test"],
+            "optional": ["cider", "clj-kondo"],
+        },
+        "haskell": {
+            "required": ["ghc", "ghci"],
+            "recommended": ["cabal", "stack"],
+            "optional": ["hlint", "haskell-language-server"],
+        },
+        "c": {
+            "required": ["gcc", "make"],
+            "recommended": ["clang", "cmake"],
+            "optional": ["gdb", "valgrind"],
+        },
+        "cpp": {
+            "required": ["g++", "make"],
+            "recommended": ["clang++", "cmake"],
+            "optional": ["gdb", "cppcheck"],
+        },
+        "lua": {
+            "required": ["lua"],
+            "recommended": ["luarocks", "busted"],
+            "optional": ["luacheck", "lua-language-server"],
+        },
+        "ocaml": {
+            "required": ["ocaml", "opam"],
+            "recommended": ["dune", "ocamlformat"],
+            "optional": ["merlin", "ocp-indent"],
+        },
+    }
+
+    def check_all(self) -> dict[str, bool]:
+        """Validate every tool.
+
+        Returns:
+            Dictionary mapping tool names to availability.
+        """
+        result = {}
+
+        # Check required tools
+        for tool, command in self.REQUIRED_TOOLS.items():
+            result[tool] = self._check_tool(command)
+
+        # Check optional tools
+        for tool, command in self.OPTIONAL_TOOLS.items():
+            result[tool] = self._check_tool(command)
+
+        return result
+
+    def _check_tool(self, command: str) -> bool:
+        """Check an individual tool.
+
+        Args:
+            command: Command to run (e.g., "git --version").
+
+        Returns:
+            True when the tool is available.
+        """
+        if not command:
+            return False
+
+        try:
+            # Extract the tool name (first token)
+            tool_name = command.split()[0]
+            # Determine availability via shutil.which
+            return shutil.which(tool_name) is not None
+        except Exception:
+            return False
+
+    def check_language_tools(self, language: str | None) -> dict[str, bool]:
+        """Validate toolchains by language.
+
+        Args:
+            language: Programming language name (e.g., "python", "typescript").
+
+        Returns:
+            Dictionary mapping tool names to availability.
+        """
+        # Guard clause: no language specified
+        if not language:
+            return {}
+
+        language_lower = language.lower()
+
+        # Guard clause: unsupported language
+        if language_lower not in self.LANGUAGE_TOOLS:
+            return {}
+
+        # Retrieve tool configuration for the language
+        tools_config = self.LANGUAGE_TOOLS[language_lower]
+
+        # Evaluate tools by category and collect results
+        result: dict[str, bool] = {}
+        for category in ["required", "recommended", "optional"]:
+            tools = tools_config.get(category, [])
+            for tool in tools:
+                result[tool] = self._is_tool_available(tool)
+
+        return result
+
+    def _is_tool_available(self, tool: str) -> bool:
+        """Check whether a tool is available (helper).
+
+        Args:
+            tool: Tool name.
+
+        Returns:
+            True when the tool is available.
+        """
+        return shutil.which(tool) is not None
+
+    def get_tool_version(self, tool: str | None) -> str | None:
+        """Retrieve tool version information.
+
+        Args:
+            tool: Tool name (for example, "python3", "node").
+
+        Returns:
+            Version string or None when the tool is unavailable.
+        """
+        # Guard clause: unspecified or unavailable tool
+        if not tool or not self._is_tool_available(tool):
+            return None
+
+        try:
+            # Call the tool with --version to obtain the version string
+            result = subprocess.run(
+                [tool, "--version"],
+                capture_output=True,
+                text=True,
+                timeout=2,  # 2-second timeout to respect performance constraints
+                check=False,
+            )
+
+            # Return the version when the command succeeds
+            if result.returncode == 0 and result.stdout:
+                return self._extract_version_line(result.stdout)
+
+            return None
+
+        except (subprocess.TimeoutExpired, OSError):
+            # Gracefully handle timeout and OS errors
+            return None
+
+    def _extract_version_line(self, version_output: str) -> str:
+        """Extract the first line from version output (helper).
+
+        Args:
+            version_output: Output captured from the --version command.
+
+        Returns:
+            First line containing version information.
+        """
+        return version_output.strip().split("\n")[0]
+
+
+def check_environment() -> dict[str, bool]:
+    """Validate the overall environment (used by the CLI doctor command).
+
+    Returns:
+        Mapping from check description to boolean status.
+    """
+    return {
+        "Python >= 3.13": sys.version_info >= (3, 13),
+        "Git installed": shutil.which("git") is not None,
+        "Project structure (.moai/)": Path(".moai").exists(),
+        "Config file (.moai/config.json)": Path(".moai/config.json").exists(),
+    }
+
+
+def get_platform_specific_message(unix_message: str, windows_message: str) -> str:
+    """Return platform-specific message.
+
+    Args:
+        unix_message: Message for Unix/Linux/macOS.
+        windows_message: Message for Windows.
+
+    Returns:
+        Platform-appropriate message.
+
+    Examples:
+        >>> get_platform_specific_message("chmod 755 .moai", "Check directory permissions")
+        'chmod 755 .moai'  # on Unix/Linux/macOS
+        >>> get_platform_specific_message("chmod 755 .moai", "Check directory permissions")
+        'Check directory permissions'  # on Windows
+    """
+    if platform.system() == "Windows":
+        return windows_message
+    return unix_message
+
+
+def get_permission_fix_message(path: str) -> str:
+    """Get platform-specific permission fix message.
+
+    Args:
+        path: Path to fix permissions for.
+
+    Returns:
+        Platform-specific fix instructions.
+    """
+    if platform.system() == "Windows":
+        return f"관리자 권한으로 실행하거나 '{path}' 디렉토리 속성에서 권한을 확인하세요"
+    return f"chmod 755 {path} 실행 후 재시도하세요"

moai_adk/core/project/detector.py

@@ -0,0 +1,105 @@
+# @CODE:CORE-PROJECT-001 | SPEC: SPEC-CORE-PROJECT-001.md | TEST: tests/unit/test_language_detector.py
+"""Language detector module.
+
+Automatically detects 20 programming languages.
+"""
+
+from pathlib import Path
+
+
+class LanguageDetector:
+    """Automatically detect up to 20 programming languages."""
+
+    LANGUAGE_PATTERNS = {
+        "python": ["*.py", "pyproject.toml", "requirements.txt", "setup.py"],
+        "typescript": ["*.ts", "tsconfig.json"],
+        "javascript": ["*.js", "package.json"],
+        "java": ["*.java", "pom.xml", "build.gradle"],
+        "go": ["*.go", "go.mod"],
+        "rust": ["*.rs", "Cargo.toml"],
+        "dart": ["*.dart", "pubspec.yaml"],
+        "swift": ["*.swift", "Package.swift"],
+        "kotlin": ["*.kt", "build.gradle.kts"],
+        "csharp": ["*.cs", "*.csproj"],
+        "php": ["*.php", "composer.json"],
+        "ruby": ["*.rb", "Gemfile"],
+        "elixir": ["*.ex", "mix.exs"],
+        "scala": ["*.scala", "build.sbt"],
+        "clojure": ["*.clj", "project.clj"],
+        "haskell": ["*.hs", "*.cabal"],
+        "c": ["*.c", "Makefile"],
+        "cpp": ["*.cpp", "CMakeLists.txt"],
+        "shell": ["*.sh", "*.bash"],
+        "lua": ["*.lua"],
+    }
+
+    def detect(self, path: str | Path = ".") -> str | None:
+        """Detect a single language (in priority order).
+
+        Args:
+            path: Directory to inspect.
+
+        Returns:
+            Detected language name (lowercase) or None.
+        """
+        path = Path(path)
+
+        # Inspect each language in priority order
+        for language, patterns in self.LANGUAGE_PATTERNS.items():
+            if self._check_patterns(path, patterns):
+                return language
+
+        return None
+
+    def detect_multiple(self, path: str | Path = ".") -> list[str]:
+        """Detect multiple languages.
+
+        Args:
+            path: Directory to inspect.
+
+        Returns:
+            List of all detected language names.
+        """
+        path = Path(path)
+        detected = []
+
+        for language, patterns in self.LANGUAGE_PATTERNS.items():
+            if self._check_patterns(path, patterns):
+                detected.append(language)
+
+        return detected
+
+    def _check_patterns(self, path: Path, patterns: list[str]) -> bool:
+        """Check whether any pattern matches.
+
+        Args:
+            path: Directory to inspect.
+            patterns: List of glob patterns.
+
+        Returns:
+            True when any pattern matches.
+        """
+        for pattern in patterns:
+            # Extension pattern (e.g., *.py)
+            if pattern.startswith("*."):
+                if list(path.rglob(pattern)):
+                    return True
+            # Specific file name (e.g., pyproject.toml)
+            else:
+                if (path / pattern).exists():
+                    return True
+
+        return False
+
+
+def detect_project_language(path: str | Path = ".") -> str | None:
+    """Detect the project language (helper).
+
+    Args:
+        path: Directory to inspect (default: current directory).
+
+    Returns:
+        Detected language name (lowercase) or None.
+    """
+    detector = LanguageDetector()
+    return detector.detect(path)

moai_adk/core/project/initializer.py

@@ -0,0 +1,174 @@
+# @CODE:CORE-PROJECT-001 | @CODE:INIT-003:INIT
+# SPEC: SPEC-CORE-PROJECT-001.md, SPEC-INIT-003.md
+# TEST: tests/unit/test_project_initializer.py, tests/unit/test_init_reinit.py
+"""Project Initialization Module
+
+Phase-based 5-step initialization process:
+1. Preparation: Backup and validation
+2. Directory: Create directory structure
+3. Resource: Copy template resources
+4. Configuration: Generate configuration files
+5. Validation: Verification and finalization
+"""
+
+import time
+from pathlib import Path
+
+from moai_adk.core.project.detector import LanguageDetector
+from moai_adk.core.project.phase_executor import PhaseExecutor, ProgressCallback
+from moai_adk.core.project.validator import ProjectValidator
+
+
+class InstallationResult:
+    """Installation result"""
+
+    def __init__(
+        self,
+        success: bool,
+        project_path: str,
+        language: str,
+        mode: str,
+        locale: str,
+        duration: int,
+        created_files: list[str],
+        errors: list[str] | None = None,
+    ) -> None:
+        self.success = success
+        self.project_path = project_path
+        self.language = language
+        self.mode = mode
+        self.locale = locale
+        self.duration = duration
+        self.created_files = created_files
+        self.errors = errors or []
+
+
+class ProjectInitializer:
+    """Project initializer (Phase-based)"""
+
+    def __init__(self, path: str | Path = ".") -> None:
+        """Initialize
+
+        Args:
+            path: Project root directory
+        """
+        self.path = Path(path).resolve()
+        self.detector = LanguageDetector()
+        self.validator = ProjectValidator()
+        self.executor = PhaseExecutor(self.validator)
+
+    def initialize(
+        self,
+        mode: str = "personal",
+        locale: str = "ko",
+        language: str | None = None,
+        backup_enabled: bool = True,
+        progress_callback: ProgressCallback | None = None,
+        reinit: bool = False,
+    ) -> InstallationResult:
+        """Execute project initialization (5-phase process)
+
+        Args:
+            mode: Project mode (personal/team)
+            locale: Locale (ko/en/ja/zh)
+            language: Force language specification (auto-detect if None)
+            backup_enabled: Whether to enable backup
+            progress_callback: Progress callback
+            reinit: Reinitialization mode (v0.3.0, SPEC-INIT-003)
+
+        Returns:
+            InstallationResult object
+
+        Raises:
+            FileExistsError: If project is already initialized (when reinit=False)
+        """
+        start_time = time.time()
+
+        try:
+            # Prevent duplicate initialization (only when not in reinit mode)
+            if self.is_initialized() and not reinit:
+                raise FileExistsError(
+                    f"Project already initialized at {self.path}/.moai/\n"
+                    f"Use 'python -m moai_adk status' to check the current configuration."
+                )
+
+            # Detect language
+            detected_language = language or self.detector.detect(self.path) or "generic"
+
+            # Phase 1: Preparation (backup and validation)
+            self.executor.execute_preparation_phase(
+                self.path, backup_enabled, progress_callback
+            )
+
+            # Phase 2: Directory (create directories)
+            self.executor.execute_directory_phase(self.path, progress_callback)
+
+            # Phase 3: Resource (copy templates)
+            resource_files = self.executor.execute_resource_phase(
+                self.path, progress_callback
+            )
+
+            # Phase 4: Configuration (generate config)
+            config = {
+                "projectName": self.path.name,
+                "mode": mode,
+                "locale": locale,
+                "language": detected_language,
+            }
+            config_files = self.executor.execute_configuration_phase(
+                self.path, config, progress_callback
+            )
+
+            # Phase 5: Validation (verify and finalize)
+            self.executor.execute_validation_phase(
+                self.path, mode, progress_callback
+            )
+
+            # Generate result
+            duration = int((time.time() - start_time) * 1000)  # ms
+            return InstallationResult(
+                success=True,
+                project_path=str(self.path),
+                language=detected_language,
+                mode=mode,
+                locale=locale,
+                duration=duration,
+                created_files=resource_files + config_files,
+            )
+
+        except Exception as e:
+            duration = int((time.time() - start_time) * 1000)
+            return InstallationResult(
+                success=False,
+                project_path=str(self.path),
+                language=language or "unknown",
+                mode=mode,
+                locale=locale,
+                duration=duration,
+                created_files=[],
+                errors=[str(e)],
+            )
+
+    def is_initialized(self) -> bool:
+        """Check if .moai/ directory exists
+
+        Returns:
+            Whether initialized
+        """
+        return (self.path / ".moai").exists()
+
+
+def initialize_project(
+    project_path: Path, progress_callback: ProgressCallback | None = None
+) -> InstallationResult:
+    """Initialize project (for CLI command)
+
+    Args:
+        project_path: Project directory path
+        progress_callback: Progress callback
+
+    Returns:
+        InstallationResult object
+    """
+    initializer = ProjectInitializer(project_path)
+    return initializer.initialize(progress_callback=progress_callback)