moai-adk 0.15.1__py3-none-any.whl → 0.25.4__py3-none-any.whl

moai_adk/core/integration/utils.py

@@ -0,0 +1,211 @@
+"""
+Integration testing utilities and helper functions.
+
+This module contains utility functions for component discovery,
+dependency resolution, and test result analysis.
+"""
+
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .models import IntegrationTestResult, TestComponent
+
+
+class ComponentDiscovery:
+    """
+    Component discovery utilities for integration testing.
+    """
+
+    @staticmethod
+    def discover_components(base_path: str) -> List[TestComponent]:
+        """
+        Discover testable components in the given path.
+
+        Args:
+            base_path: Base path to search for components
+
+        Returns:
+            List of discovered components
+        """
+        components = []
+        base_dir = Path(base_path)
+
+        if not base_dir.exists():
+            return components
+
+        # Look for Python modules
+        for py_file in base_dir.rglob("*.py"):
+            if py_file.name.startswith("__"):
+                continue
+
+            relative_path = py_file.relative_to(base_dir)
+            module_name = str(relative_path.with_suffix("")).replace("/", ".")
+
+            component = TestComponent(
+                name=module_name,
+                component_type="python_module",
+                version="1.0.0",  # Default version
+            )
+            components.append(component)
+
+        return components
+
+    @staticmethod
+    def resolve_dependencies(components: List[TestComponent]) -> Dict[str, List[str]]:
+        """
+        Resolve dependencies between components.
+
+        Args:
+            components: List of components to analyze
+
+        Returns:
+            Dictionary mapping component names to their dependencies
+        """
+        dependency_map = {}
+
+        for component in components:
+            try:
+                # Try to import and analyze dependencies
+                dependencies = ComponentDiscovery._analyze_imports(component)
+                dependency_map[component.name] = dependencies
+            except Exception:
+                dependency_map[component.name] = component.dependencies
+
+        return dependency_map
+
+    @staticmethod
+    def _analyze_imports(component: TestComponent) -> List[str]:
+        """
+        Analyze imports for a component to determine dependencies.
+
+        Args:
+            component: Component to analyze
+
+        Returns:
+            List of dependency names
+        """
+        # This is a simplified implementation
+        # In a real scenario, you would parse the source code
+        return component.dependencies
+
+
+class TestResultAnalyzer:
+    """
+    Test result analysis utilities.
+    """
+
+    @staticmethod
+    def calculate_success_rate(results: List[IntegrationTestResult]) -> float:
+        """
+        Calculate the success rate of test results.
+
+        Args:
+            results: List of test results
+
+        Returns:
+            Success rate as percentage (0-100)
+        """
+        if not results:
+            return 0.0
+
+        passed = sum(1 for result in results if result.passed)
+        return (passed / len(results)) * 100
+
+    @staticmethod
+    def get_failed_tests(
+        results: List[IntegrationTestResult],
+    ) -> List[IntegrationTestResult]:
+        """
+        Get list of failed tests.
+
+        Args:
+            results: List of test results
+
+        Returns:
+            List of failed test results
+        """
+        return [result for result in results if not result.passed]
+
+    @staticmethod
+    def get_execution_stats(results: List[IntegrationTestResult]) -> Dict[str, Any]:
+        """
+        Get execution statistics for test results.
+
+        Args:
+            results: List of test results
+
+        Returns:
+            Dictionary with execution statistics
+        """
+        if not results:
+            return {
+                "total": 0,
+                "passed": 0,
+                "failed": 0,
+                "success_rate": 0.0,
+                "total_time": 0.0,
+                "avg_time": 0.0,
+            }
+
+        passed = sum(1 for result in results if result.passed)
+        failed = len(results) - passed
+        total_time = sum(result.execution_time for result in results)
+
+        return {
+            "total": len(results),
+            "passed": passed,
+            "failed": failed,
+            "success_rate": TestResultAnalyzer.calculate_success_rate(results),
+            "total_time": total_time,
+            "avg_time": total_time / len(results),
+        }
+
+
+class TestEnvironment:
+    """
+    Test environment management utilities.
+    """
+
+    def __init__(self, temp_dir: Optional[str] = None):
+        """
+        Initialize test environment.
+
+        Args:
+            temp_dir: Optional temporary directory path
+        """
+        self.temp_dir = temp_dir
+        self.created_temp = False
+
+        if self.temp_dir is None:
+            self.temp_dir = tempfile.mkdtemp(prefix="moai_integration_test_")
+            self.created_temp = True
+
+    def cleanup(self):
+        """Clean up test environment."""
+        if self.created_temp and self.temp_dir:
+            try:
+                shutil.rmtree(self.temp_dir)
+            except Exception:
+                pass  # Ignore cleanup errors
+
+    def get_temp_path(self, name: str) -> str:
+        """
+        Get a temporary file path.
+
+        Args:
+            name: File name
+
+        Returns:
+            Full path to temporary file
+        """
+        return str(Path(self.temp_dir) / name)
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.cleanup()

moai_adk/core/issue_creator.py

@@ -4,8 +4,6 @@ GitHub Issue Creator for MoAI-ADK quick issue reporting.
 Enables users to quickly create GitHub Issues with standardized templates
 using `/alfred:9-feedback` interactive dialog.
 
-@TAG:ISSUE-CREATOR-001 - GitHub issue creation system
-@TAG:QUICK-REPORTING-001 - Quick issue reporting functionality
 """
 
 import subprocess
@@ -16,6 +14,7 @@ from typing import Any, Dict, List, Optional
 
 class IssueType(Enum):
     """Supported GitHub issue types."""
+
     BUG = "bug"
     FEATURE = "feature"
     IMPROVEMENT = "improvement"
@@ -24,6 +23,7 @@ class IssueType(Enum):
 
 class IssuePriority(Enum):
     """Issue priority levels."""
+
     CRITICAL = "critical"
     HIGH = "high"
     MEDIUM = "medium"
@@ -33,6 +33,7 @@ class IssuePriority(Enum):
 @dataclass
 class IssueConfig:
     """Configuration for issue creation."""
+
     issue_type: IssueType
     title: str
     description: str
@@ -59,7 +60,10 @@ class GitHubIssueCreator:
         IssueType.BUG: ["bug", "reported"],
         IssueType.FEATURE: ["feature-request", "enhancement"],
         IssueType.IMPROVEMENT: ["improvement", "enhancement"],
-        IssueType.QUESTION: ["question", "help wanted"],  # Fixed: "help-wanted" → "help wanted" (GitHub standard)
+        IssueType.QUESTION: [
+            "question",
+            "help wanted",
+        ],  # Fixed: "help-wanted" → "help wanted" (GitHub standard)
     }
 
     # Priority emoji
@@ -97,10 +101,7 @@ class GitHubIssueCreator:
         """
         try:
             result = subprocess.run(
-                ["gh", "auth", "status"],
-                capture_output=True,
-                text=True,
-                timeout=5
+                ["gh", "auth", "status"], capture_output=True, text=True, timeout=5
             )
             if result.returncode != 0:
                 raise RuntimeError(
@@ -145,7 +146,9 @@ class GitHubIssueCreator:
         # Collect labels
         labels = self.LABEL_MAP.get(config.issue_type, []).copy()
         if config.priority:
-            labels.append(config.priority.value)  # Fixed: removed "priority-" prefix (use direct label names)
+            labels.append(
+                config.priority.value
+            )  # Fixed: removed "priority-" prefix (use direct label names)
         if config.category:
             labels.append(f"category-{config.category.lower().replace(' ', '-')}")
         if config.custom_labels:
@@ -153,9 +156,13 @@ class GitHubIssueCreator:
 
         # Build gh command
         gh_command = [
-            "gh", "issue", "create",
-            "--title", full_title,
-            "--body", body,
+            "gh",
+            "issue",
+            "create",
+            "--title",
+            full_title,
+            "--body",
+            body,
         ]
 
         # Add labels
@@ -168,10 +175,7 @@ class GitHubIssueCreator:
 
         try:
             result = subprocess.run(
-                gh_command,
-                capture_output=True,
-                text=True,
-                timeout=30
+                gh_command, capture_output=True, text=True, timeout=30
             )
 
             if result.returncode != 0:
@@ -256,7 +260,9 @@ class GitHubIssueCreator:
                 output += f"🏷️  Labels: {', '.join(result['labels'])}\n"
             return output
         else:
-            return f"❌ Failed to create issue: {result.get('message', 'Unknown error')}"
+            return (
+                f"❌ Failed to create issue: {result.get('message', 'Unknown error')}"
+            )
 
 
 class IssueCreatorFactory:
@@ -265,7 +271,9 @@ class IssueCreatorFactory:
     """
 
     @staticmethod
-    def create_bug_issue(title: str, description: str, priority: IssuePriority = IssuePriority.HIGH) -> IssueConfig:
+    def create_bug_issue(
+        title: str, description: str, priority: IssuePriority = IssuePriority.HIGH
+    ) -> IssueConfig:
         """Create a bug report issue configuration."""
         return IssueConfig(
             issue_type=IssueType.BUG,
@@ -302,7 +310,9 @@ class IssueCreatorFactory:
         )
 
     @staticmethod
-    def create_question_issue(title: str, description: str, priority: IssuePriority = IssuePriority.LOW) -> IssueConfig:
+    def create_question_issue(
+        title: str, description: str, priority: IssuePriority = IssuePriority.LOW
+    ) -> IssueConfig:
         """Create a question/discussion issue configuration."""
         return IssueConfig(
             issue_type=IssueType.QUESTION,

moai_adk/core/language_config.py

@@ -0,0 +1,202 @@
+"""
+Enhanced language configuration for MoAI-ADK.
+
+Supports extended language list with native names and automatic translation capabilities.
+"""
+
+from typing import Dict, Optional
+
+# Enhanced language configuration with native names
+LANGUAGE_CONFIG: Dict[str, Dict[str, str]] = {
+    "en": {
+        "name": "English",
+        "native_name": "English",
+        "code": "en",
+        "family": "indo-european",
+    },
+    "ko": {
+        "name": "Korean",
+        "native_name": "한국어",
+        "code": "ko",
+        "family": "koreanic",
+    },
+    "ja": {
+        "name": "Japanese",
+        "native_name": "日本語",
+        "code": "ja",
+        "family": "japonic",
+    },
+    "es": {
+        "name": "Spanish",
+        "native_name": "Español",  # Spanish native representation
+        "code": "es",
+        "family": "indo-european",
+    },
+    "fr": {
+        "name": "French",
+        "native_name": "Français",
+        "code": "fr",
+        "family": "indo-european",
+    },
+    "de": {
+        "name": "German",
+        "native_name": "Deutsch",
+        "code": "de",
+        "family": "indo-european",
+    },
+    "zh": {
+        "name": "Chinese",
+        "native_name": "中文",
+        "code": "zh",
+        "family": "sino-tibetan",
+    },
+    "pt": {
+        "name": "Portuguese",
+        "native_name": "Português",
+        "code": "pt",
+        "family": "indo-european",
+    },
+    "ru": {
+        "name": "Russian",
+        "native_name": "Русский",
+        "code": "ru",
+        "family": "indo-european",
+    },
+    "it": {
+        "name": "Italian",
+        "native_name": "Italiano",
+        "code": "it",
+        "family": "indo-european",
+    },
+    "ar": {
+        "name": "Arabic",
+        "native_name": "العربية",
+        "code": "ar",
+        "family": "afro-asiatic",
+    },
+    "hi": {
+        "name": "Hindi",
+        "native_name": "हिन्दी",
+        "code": "hi",
+        "family": "indo-european",
+    },
+}
+
+
+def get_language_info(language_code: str) -> Optional[Dict[str, str]]:
+    """Get language information by code.
+
+    Args:
+        language_code: ISO language code (e.g., 'ko', 'en')
+
+    Returns:
+        Language information dictionary or None if not found
+    """
+    return LANGUAGE_CONFIG.get(language_code.lower())
+
+
+def get_native_name(language_code: str) -> str:
+    """Get native language name.
+
+    Args:
+        language_code: ISO language code
+
+    Returns:
+        Native language name or English fallback
+    """
+    lang_info = get_language_info(language_code)
+    return lang_info["native_name"] if lang_info else "English"
+
+
+def get_english_name(language_code: str) -> str:
+    """Get English language name.
+
+    Args:
+        language_code: ISO language code
+
+    Returns:
+        English language name or fallback
+    """
+    lang_info = get_language_info(language_code)
+    return lang_info["name"] if lang_info else "English"
+
+
+def get_all_supported_codes() -> list[str]:
+    """Get list of all supported language codes."""
+    return list(LANGUAGE_CONFIG.keys())
+
+
+def get_language_family(language_code: str) -> Optional[str]:
+    """Get language family for linguistic analysis.
+
+    Args:
+        language_code: ISO language code
+
+    Returns:
+        Language family string or None
+    """
+    lang_info = get_language_info(language_code)
+    return lang_info.get("family") if lang_info else None
+
+
+# Language to Claude model mapping for optimal performance
+LANGUAGE_MODEL_PREFERENCE: Dict[str, str] = {
+    "en": "claude-sonnet-4-5-20250929",  # Best for English
+    "ko": "claude-sonnet-4-5-20250929",  # Strong Korean support
+    "ja": "claude-sonnet-4-5-20250929",  # Strong Japanese support
+    "es": "claude-sonnet-4-5-20250929",  # Strong Spanish support
+    "fr": "claude-sonnet-4-5-20250929",  # Strong French support
+    "de": "claude-sonnet-4-5-20250929",  # Strong German support
+    "zh": "claude-sonnet-4-5-20250929",  # Strong Chinese support
+    "pt": "claude-sonnet-4-5-20250929",  # Portuguese support
+    "ru": "claude-sonnet-4-5-20250929",  # Russian support
+    "it": "claude-sonnet-4-5-20250929",  # Italian support
+    "ar": "claude-sonnet-4-5-20250929",  # Arabic support
+    "hi": "claude-sonnet-4-5-20250929",  # Hindi support
+}
+
+
+def get_optimal_model(language_code: str) -> str:
+    """Get optimal Claude model for specific language.
+
+    Args:
+        language_code: ISO language code
+
+    Returns:
+        Recommended Claude model identifier
+    """
+    return LANGUAGE_MODEL_PREFERENCE.get(language_code, "claude-sonnet-4-5-20250929")
+
+
+# RTL (Right-to-Left) language detection
+RTL_LANGUAGES = {"ar", "he", "fa", "ur"}
+
+
+def is_rtl_language(language_code: str) -> bool:
+    """Check if language uses right-to-left script.
+
+    Args:
+        language_code: ISO language code
+
+    Returns:
+        True if RTL language, False otherwise
+    """
+    return language_code.lower() in RTL_LANGUAGES
+
+
+# Translation priorities for descriptions
+TRANSLATION_PRIORITY = [
+    "en",  # English base
+    "ko",  # Korean
+    "ja",  # Japanese
+    "es",  # Spanish
+    "fr",  # French
+    "de",  # German
+    "zh",  # Chinese
+    "pt",  # Portuguese
+]
+
+
+def get_translation_priority() -> list[str]:
+    """Get language translation priority order."""
+    return TRANSLATION_PRIORITY.copy()