moai-adk 0.4.5__py3-none-any.whl → 0.20.1__py3-none-any.whl

moai_adk/core/mcp/setup_old.py

@@ -0,0 +1,296 @@
+# @CODE:MCP-SETUP-001 | SPEC: SPEC-MCP-SETUP-001/spec.md
+"""MCP (Model Context Protocol) Setup and Configuration
+
+Handles MCP server installation, configuration, and management for MoAI-ADK projects.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Dict, List
+
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+
+console = Console()
+
+
+class MCPSetupManager:
+    """Manages MCP server setup and configuration"""
+
+    def __init__(self, project_path: Path):
+        self.project_path = project_path
+        self.settings_path = project_path / ".claude" / "settings.json"
+
+    def get_npm_global_path(self) -> str:
+        """Get npm global modules path"""
+        try:
+            result = subprocess.run(
+                ["npm", "root", "-g"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout.strip()
+        except subprocess.CalledProcessError:
+            return "/usr/local/lib/node_modules"
+
+    def check_npm_package_installed(self, package: str) -> bool:
+        """Check if npm package is installed globally"""
+        try:
+            result = subprocess.run(
+                ["npm", "list", "-g", package],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return package in result.stdout
+        except subprocess.CalledProcessError:
+            return False
+
+    def install_mcp_server(self, package: str, display_name: str) -> bool:
+        """Install MCP server globally"""
+        console.print(f"📦 Installing {display_name}...")
+
+        try:
+            subprocess.run(
+                ["npm", "install", "-g", package],
+                check=True,
+                capture_output=True
+            )
+            console.print(f"✅ {display_name} installed successfully")
+            return True
+        except subprocess.CalledProcessError as e:
+            console.print(f"❌ Failed to install {display_name}: {e}")
+            return False
+
+    def detect_mcp_servers(self, servers: List[str]) -> Dict[str, bool]:
+        """Detect installation status of MCP servers"""
+        status = {}
+
+        package_mapping = {
+            "context7": "@upstash/context7-mcp",
+            "playwright": "@playwright/mcp",
+            "sequential-thinking": "@modelcontextprotocol/server-sequential-thinking"
+        }
+
+        for server in servers:
+            package = package_mapping.get(server)
+            if package:
+                status[server] = self.check_npm_package_installed(package)
+            else:
+                status[server] = False
+
+        return status
+
+    def install_mcp_servers(self, servers: List[str]) -> Dict[str, bool]:
+        """Install specified MCP servers"""
+        results = {}
+
+        package_mapping = {
+            "context7": ("@upstash/context7-mcp", "Context7 MCP"),
+            "playwright": ("@playwright/mcp", "Playwright MCP"),
+            "sequential-thinking": ("@modelcontextprotocol/server-sequential-thinking", "Sequential Thinking MCP")
+        }
+
+        for server in servers:
+            if server in package_mapping:
+                package, display_name = package_mapping[server]
+                results[server] = self.install_mcp_server(package, display_name)
+            else:
+                console.print(f"⚠️  Unknown MCP server: {server}")
+                results[server] = False
+
+        return results
+
+    def generate_mcp_config(self, installed_servers: Dict[str, bool]) -> Dict:
+        """Generate MCP configuration following Microsoft MCP standard"""
+        config = {"servers": {}}
+
+        # Context7 MCP
+        if installed_servers.get("context7", False):
+            config["servers"]["context7"] = {
+                "type": "stdio",
+                "command": "npx",
+                "args": [
+                    "-y",
+                    "@upstash/context7-mcp"
+                ],
+                "env": {}
+            }
+
+
+        # Playwright MCP
+        if installed_servers.get("playwright", False):
+            config["servers"]["playwright"] = {
+                "type": "stdio",
+                "command": "npx",
+                "args": [
+                    "-y",
+                    "@playwright/mcp"
+                ],
+                "env": {}
+            }
+
+        # Sequential Thinking MCP
+        if installed_servers.get("sequential-thinking", False):
+            config["servers"]["sequential-thinking"] = {
+                "type": "stdio",
+                "command": "npx",
+                "args": [
+                    "-y",
+                    "@modelcontextprotocol/server-sequential-thinking"
+                ],
+                "env": {}
+            }
+
+        return config
+
+    def backup_settings(self) -> bool:
+        """Backup existing settings file (legacy - not used for MCP)"""
+        # Settings backup is no longer needed for MCP setup
+        # We only create .mcp.json in project root
+        return True
+
+    def update_mcp_file(self, mcp_config: Dict) -> bool:
+        """Update MCP configuration file following Microsoft MCP standard (legacy - not used)"""
+        # This method is no longer used - we only create .mcp.json in project root
+        return True
+
+    def create_project_mcp_file(self, mcp_config: Dict) -> bool:
+        """Create .mcp.json file in project root for Claude Code compatibility"""
+        try:
+            # Create .mcp.json path in project root
+            mcp_root_path = self.project_path / ".mcp.json"
+
+            # Write MCP configuration to project root
+            with open(mcp_root_path, 'w') as f:
+                json.dump(mcp_config, f, indent=2)
+
+            console.print("✅ Project MCP file created (.mcp.json)")
+            return True
+
+        except Exception as e:
+            console.print(f"❌ Failed to create project MCP file: {e}")
+            return False
+
+    def update_settings_file(self, mcp_config: Dict) -> bool:
+        """Update Claude Code settings file with MCP configuration (legacy - not used)"""
+        # This method is no longer used - we only create .mcp.json in project root
+        return True
+
+    def copy_template_mcp_config(self) -> bool:
+        """Copy MCP configuration from package template"""
+        try:
+            # Get the package template path
+            import moai_adk
+            package_path = Path(moai_adk.__file__).parent
+            template_mcp_path = package_path / "templates" / ".mcp.json"
+
+            if template_mcp_path.exists():
+                # Copy template to project
+                project_mcp_path = self.project_path / ".mcp.json"
+
+                # Read template
+                with open(template_mcp_path, 'r') as f:
+                    mcp_config = json.load(f)
+
+                # Write to project
+                with open(project_mcp_path, 'w') as f:
+                    json.dump(mcp_config, f, indent=2)
+
+                server_names = list(mcp_config.get('mcpServers', {}).keys())
+                console.print("✅ MCP configuration copied from template")
+                console.print(f"📋 Configured servers: {', '.join(server_names)}")
+                return True
+            else:
+                console.print("❌ Template MCP configuration not found")
+                return False
+
+        except Exception as e:
+            console.print(f"❌ Failed to copy MCP configuration: {e}")
+            return False
+
+    def setup_mcp_servers(self, selected_servers: List[str]) -> bool:
+        """Complete MCP server setup process"""
+        if not selected_servers:
+            console.print("ℹ️  No MCP servers selected")
+            return True
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]"),
+            BarColumn(),
+            console=console
+        ) as progress:
+            task = progress.add_task("Setting up MCP servers...", total=100)
+
+            # Step 1: Detect installation status
+            progress.update(task, completed=10, description="Detecting server installation...")
+            installed_status = self.detect_mcp_servers(selected_servers)
+
+            # Step 2: Install missing servers
+            missing_servers = [s for s in selected_servers if not installed_status.get(s, False)]
+            if missing_servers:
+                progress.update(task, completed=30, description="Installing missing servers...")
+                install_results = self.install_mcp_servers(missing_servers)
+
+                # Update status with installation results
+                for server, result in install_results.items():
+                    installed_status[server] = result
+
+            # Step 3: Generate configuration
+            progress.update(task, completed=70, description="Generating configuration...")
+            mcp_config = self.generate_mcp_config(installed_status)
+
+            # Step 4: Create .mcp.json in project root for Claude Code compatibility only
+            progress.update(task, completed=80, description="Creating project MCP file...")
+            success = self.create_project_mcp_file(mcp_config)
+
+            # Step 5: Final verification
+            progress.update(task, completed=100, description="Final verification...")
+
+            if success:
+                console.print("\n🎉 MCP setup completed successfully!")
+                console.print(f"📋 Configured servers: {', '.join([s for s, installed in installed_status.items() if installed])}")
+
+
+                return True
+            else:
+                console.print("\n❌ MCP setup failed")
+                return False
+
+    def get_installed_servers(self) -> List[str]:
+        """Get list of currently installed MCP servers"""
+        all_servers = ["context7", "playwright", "sequential-thinking"]
+        status = self.detect_mcp_servers(all_servers)
+        return [server for server, installed in status.items() if installed]
+
+    def verify_mcp_configuration(self) -> Dict[str, bool]:
+        """Verify MCP configuration and server availability"""
+        mcp_path = self.project_path / ".claude" / "mcp.json"
+
+        if not mcp_path.exists():
+            return {"config_exists": False, "servers_configured": 0}
+
+        try:
+            with open(mcp_path, 'r') as f:
+                config = json.load(f)
+
+            servers = config.get("servers", {})
+            installed_servers = self.get_installed_servers()
+
+            verification = {
+                "config_exists": True,
+                "servers_configured": len(servers),
+                "servers_available": len(installed_servers),
+                "server_status": {}
+            }
+
+            for server_name in servers.keys():
+                verification["server_status"][server_name] = server_name in installed_servers
+
+            return verification
+
+        except Exception as e:
+            return {"config_exists": False, "error": str(e)}

moai_adk/core/project/backup_utils.py

@@ -1,4 +1,4 @@
-# @CODE:INIT-003:BACKUP | SPEC: .moai/specs/SPEC-INIT-003/spec.md | TEST: tests/unit/test_backup_utils.py
+# @CODE:INIT-005:BACKUP | SPEC: .moai/specs/SPEC-INIT-003/spec.md | TEST: tests/unit/test_backup_utils.py
 """Backup utility module (SPEC-INIT-003 v0.3.0)
 
 Selective backup strategy:

moai_adk/core/project/checker.py

@@ -1,4 +1,4 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001.md | TEST: tests/unit/test_cli_commands.py
+# @CODE:CLI-003 | SPEC: SPEC-CLI-001.md | TEST: tests/unit/test_cli_commands.py
 """System requirements validation module.
 
 Checks whether required and optional tools are installed.
@@ -24,7 +24,7 @@ class SystemChecker:
         "docker": "docker --version",
     }
 
-    # @CODE:CLI-001:DATA - Language toolchain mapping (20 languages)
+    # @CODE:CLI-003:DATA - Language toolchain mapping (20 languages)
     LANGUAGE_TOOLS: dict[str, dict[str, list[str]]] = {
         "python": {
             "required": ["python3", "pip"],

moai_adk/core/project/detector.py

@@ -1,8 +1,16 @@
 # @CODE:CORE-PROJECT-001 | SPEC: SPEC-CORE-PROJECT-001.md | TEST: tests/unit/test_language_detector.py
 # @CODE:LANG-DETECT-001 | SPEC: SPEC-LANG-DETECT-001.md | TEST: tests/unit/test_detector.py
+# @CODE:LDE-EXTENDED-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md | \
+# 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
@@ -16,7 +24,28 @@ class LanguageDetector:
     """
 
     LANGUAGE_PATTERNS = {
-        # PHP moved to top for priority (Laravel detection)
+        # @CODE:LDE-PRIORITY-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+        # 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)
+        # @CODE:LANG-DETECT-RUBY-001 | SPEC: Issue #51 Language Detection Fix
+        "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",
@@ -24,24 +53,18 @@ class LanguageDetector:
             "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"],
-        "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"],
-        "ruby": ["*.rb", "Gemfile"],
+        "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"],
-        "c": ["*.c", "Makefile"],
-        "cpp": ["*.cpp", "CMakeLists.txt"],
-        "shell": ["*.sh", "*.bash"],
         "lua": ["*.lua"],
     }
 
@@ -103,6 +126,182 @@ class LanguageDetector:
 
         return False
 
+    def get_workflow_template_path(self, language: str) -> str:
+        """Get the GitHub Actions workflow template path for a language.
+
+        @CODE:LDE-WORKFLOW-PATH-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        Args:
+            language: Programming language name (lowercase).
+
+        Returns:
+            Workflow template file path relative to templates directory.
+
+        Raises:
+            ValueError: If language is not supported for workflows.
+        """
+        workflow_mapping = {
+            "python": ".github/workflows/python-tag-validation.yml",
+            "javascript": ".github/workflows/javascript-tag-validation.yml",
+            "typescript": ".github/workflows/typescript-tag-validation.yml",
+            "go": ".github/workflows/go-tag-validation.yml",
+            "ruby": ".github/workflows/ruby-tag-validation.yml",
+            "php": ".github/workflows/php-tag-validation.yml",
+            "java": ".github/workflows/java-tag-validation.yml",
+            "rust": ".github/workflows/rust-tag-validation.yml",
+            "dart": ".github/workflows/dart-tag-validation.yml",
+            "swift": ".github/workflows/swift-tag-validation.yml",
+            "kotlin": ".github/workflows/kotlin-tag-validation.yml",
+            "csharp": ".github/workflows/csharp-tag-validation.yml",
+            "c": ".github/workflows/c-tag-validation.yml",
+            "cpp": ".github/workflows/cpp-tag-validation.yml",
+            "shell": ".github/workflows/shell-tag-validation.yml",
+        }
+
+        if language.lower() not in workflow_mapping:
+            raise ValueError(
+                f"Unsupported language: {language}. "
+                f"Supported languages: {', '.join(workflow_mapping.keys())}"
+            )
+
+        return workflow_mapping[language.lower()]
+
+    def detect_package_manager(self, path: str | Path = ".") -> str | None:
+        """Detect the package manager for the detected language.
+
+        @CODE:LDE-PKG-MGR-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        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.
+
+        @CODE:LDE-BUILD-TOOL-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        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.
+
+        @CODE:LDE-SUPPORTED-LANGS-001 | SPEC: SPEC-LANGUAGE-DETECTION-EXTENDED-001/spec.md
+
+        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).