moai-adk 0.35.1__py3-none-any.whl

moai_adk/core/project/__init__.py

@@ -0,0 +1 @@
+"""Project module: initialization and management"""

moai_adk/core/project/backup_utils.py

@@ -0,0 +1,70 @@
+"""Backup utility module (SPEC-INIT-003 v0.3.0)
+
+Selective backup strategy:
+- Back up only the required files (OR condition)
+- Backup path: .moai-backups/backup/ (v0.4.2)
+"""
+
+from pathlib import Path
+
+# Backup targets (OR condition - back up when any exist)
+BACKUP_TARGETS = [
+    ".moai/config/config.json",
+    ".moai/project/",
+    ".moai/memory/",
+    ".claude/",
+    ".github/",
+    "CLAUDE.md",
+]
+
+# User data protection paths (excluded from backups)
+PROTECTED_PATHS = [
+    ".moai/specs/",
+    ".moai/reports/",
+]
+
+
+def has_any_moai_files(project_path: Path) -> bool:
+    """Check whether any MoAI-ADK files exist (OR condition).
+
+    Args:
+        project_path: Project path.
+
+    Returns:
+        True when any backup target exists.
+    """
+    for target in BACKUP_TARGETS:
+        target_path = project_path / target
+        if target_path.exists():
+            return True
+    return False
+
+
+def get_backup_targets(project_path: Path) -> list[str]:
+    """Return existing backup targets.
+
+    Args:
+        project_path: Project path.
+
+    Returns:
+        List of backup targets that exist.
+    """
+    targets: list[str] = []
+    for target in BACKUP_TARGETS:
+        target_path = project_path / target
+        if target_path.exists():
+            targets.append(target)
+    return targets
+
+
+def is_protected_path(rel_path: Path) -> bool:
+    """Check whether the path is protected.
+
+    Args:
+        rel_path: Relative path.
+
+    Returns:
+        True when the path should be excluded from backups.
+    """
+    rel_str = str(rel_path).replace("\\", "/")
+    return any(rel_str.startswith(p.lstrip("./").rstrip("/")) for p in PROTECTED_PATHS)

moai_adk/core/project/checker.py

@@ -0,0 +1,300 @@
+"""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",
+    }
+
+    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.11": sys.version_info >= (3, 11),
+        "Git installed": shutil.which("git") is not None,
+        "Project structure (.moai/)": Path(".moai").exists(),
+        "Config file (.moai/config/config.yaml)": Path(".moai/config/config.yaml").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"Run with administrator privileges or verify permissions in the properties of the '{path}' directory"
+    return f"Run 'chmod 755 {path}' and try again"

moai_adk/core/project/detector.py

@@ -0,0 +1,293 @@
+# TEST: tests/unit/test_language_detector_extended.py
+"""Language detector module.
+
+Automatically detects 20 programming languages.
+
+Extended detection supports:
+- 11 new languages: Ruby, PHP, Java, Rust, Dart, Swift, Kotlin, C#, C, C++, Shell
+- 5 build tool detection: Maven, Gradle, CMake, SPM, dotnet
+- Package manager detection: bundle, composer, cargo
+- Priority conflict resolution for multi-language projects
+"""
+
+from pathlib import Path
+
+
+class LanguageDetector:
+    """Automatically detect up to 20 programming languages.
+
+    Prioritizes framework-specific files (e.g., Laravel, Django) over
+    generic language files to improve accuracy in mixed-language projects.
+    """
+
+    LANGUAGE_PATTERNS = {
+        # Priority order (highest to lowest):
+        # 1. Rust, 2. Dart, 3. Swift, 4. Kotlin, 5. C#, 6. Java, 7. Ruby, 8. PHP
+        # 9. Go, 10. Python, 11. TypeScript, 12. JavaScript, 13. C++, 14. C, 15. Shell
+        "rust": ["*.rs", "Cargo.toml"],
+        "dart": ["*.dart", "pubspec.yaml"],
+        "swift": ["*.swift", "Package.swift"],
+        "kotlin": ["*.kt", "build.gradle.kts"],
+        "csharp": ["*.cs", "*.csproj"],
+        "java": ["*.java", "pom.xml", "build.gradle"],
+        # Ruby moved for priority (Rails detection)
+        "ruby": [
+            "*.rb",
+            "Gemfile",
+            "Gemfile.lock",  # Bundler: lock file (unique to Ruby)
+            "config/routes.rb",  # Rails: routing file (unique identifier)
+            "app/controllers/",  # Rails: controller directory
+            "Rakefile",  # Rails/Ruby: task file
+        ],
+        # PHP after Ruby (Laravel detection)
+        "php": [
+            "*.php",
+            "composer.json",
+            "artisan",  # Laravel: CLI tool (unique identifier)
+            "app/",  # Laravel: application directory
+            "bootstrap/laravel.php",  # Laravel: bootstrap file
+        ],
+        "go": ["*.go", "go.mod"],
+        "python": ["*.py", "pyproject.toml", "requirements.txt", "setup.py"],
+        "typescript": ["*.ts", "tsconfig.json"],
+        "javascript": ["*.js", "package.json"],
+        "cpp": ["*.cpp", "CMakeLists.txt"],
+        "c": ["*.c", "Makefile"],
+        "shell": ["*.sh", "*.bash"],
+        # Additional languages (lower priority)
+        "elixir": ["*.ex", "mix.exs"],
+        "scala": ["*.scala", "build.sbt"],
+        "clojure": ["*.clj", "project.clj"],
+        "haskell": ["*.hs", "*.cabal"],
+        "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 get_workflow_template_path(self, language: str) -> str:
+        """Get the GitHub Actions workflow template path for a language.
+
+
+        Args:
+            language: Programming language name (lowercase).
+
+        Returns:
+            Workflow template file path relative to templates directory.
+
+        Raises:
+            ValueError: If language is not supported for workflows.
+        """
+        # Language-specific workflow template mapping
+        workflow_templates = {
+            "python": "python-tag-validation.yml",
+            "javascript": "javascript-tag-validation.yml",
+            "typescript": "typescript-tag-validation.yml",
+            "go": "go-tag-validation.yml",
+        }
+
+        if language not in workflow_templates:
+            raise ValueError(f"Language '{language}' is not supported for workflows")
+
+        return workflow_templates[language]
+
+    def detect_package_manager(self, path: str | Path = ".") -> str | None:
+        """Detect the package manager for the detected language.
+
+
+        Args:
+            path: Directory to inspect.
+
+        Returns:
+            Package manager name or None if not detected.
+        """
+        path = Path(path)
+
+        # Ruby
+        if (path / "Gemfile").exists():
+            return "bundle"
+
+        # PHP
+        if (path / "composer.json").exists():
+            return "composer"
+
+        # Java/Kotlin
+        if (path / "pom.xml").exists():
+            return "maven"
+        if (path / "build.gradle").exists() or (path / "build.gradle.kts").exists():
+            return "gradle"
+
+        # Rust
+        if (path / "Cargo.toml").exists():
+            return "cargo"
+
+        # Dart/Flutter
+        if (path / "pubspec.yaml").exists():
+            return "dart_pub"
+
+        # Swift
+        if (path / "Package.swift").exists():
+            return "spm"
+
+        # C#
+        if list(path.glob("*.csproj")) or list(path.glob("*.sln")):
+            return "dotnet"
+
+        # Python
+        if (path / "pyproject.toml").exists():
+            return "pip"
+
+        # JavaScript/TypeScript (check in priority order)
+        # Check for lock files and package managers
+        if (path / "bun.lockb").exists():
+            return "bun"
+        elif (path / "pnpm-lock.yaml").exists():
+            return "pnpm"
+        elif (path / "yarn.lock").exists():
+            return "yarn"
+        elif (path / "package-lock.json").exists():
+            return "npm"
+        elif (path / "package.json").exists():
+            # Default to npm for package.json without lock files
+            return "npm"
+
+        # Go
+        if (path / "go.mod").exists():
+            return "go_modules"
+
+        return None
+
+    def detect_build_tool(self, path: str | Path = ".", language: str | None = None) -> str | None:
+        """Detect the build tool for the detected language.
+
+
+        Args:
+            path: Directory to inspect.
+            language: Optional language hint for disambiguation.
+
+        Returns:
+            Build tool name or None if not detected.
+        """
+        path = Path(path)
+
+        # C/C++
+        if (path / "CMakeLists.txt").exists():
+            return "cmake"
+        if (path / "Makefile").exists():
+            return "make"
+
+        # Java/Kotlin
+        if language in ["java", "kotlin"]:
+            if (path / "pom.xml").exists():
+                return "maven"
+            if (path / "build.gradle").exists() or (path / "build.gradle.kts").exists():
+                return "gradle"
+
+        # Rust
+        if (path / "Cargo.toml").exists():
+            return "cargo"
+
+        # Swift
+        if (path / "Package.swift").exists():
+            return "spm"
+        if list(path.glob("*.xcodeproj")) or list(path.glob("*.xcworkspace")):
+            return "xcode"
+
+        # C#
+        if list(path.glob("*.csproj")) or list(path.glob("*.sln")):
+            return "dotnet"
+
+        return None
+
+    def get_supported_languages_for_workflows(self) -> list[str]:
+        """Get the list of languages with dedicated CI/CD workflow support.
+
+
+        Returns:
+            List of supported language names (15 total).
+        """
+        return [
+            "python",
+            "javascript",
+            "typescript",
+            "go",
+            "ruby",
+            "php",
+            "java",
+            "rust",
+            "dart",
+            "swift",
+            "kotlin",
+            "csharp",
+            "c",
+            "cpp",
+            "shell",
+        ]
+
+
+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)