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

moai_adk/templates/.claude/hooks/moai/lib/language_validator.py

@@ -0,0 +1,407 @@
+#!/usr/bin/env python3
+"""Language Configuration Validator for MoAI-ADK
+
+Validates language configuration settings and ensures proper functionality.
+Provides detailed diagnostics for language-related issues.
+"""
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+
+try:
+    import yaml
+
+    YAML_AVAILABLE = True
+except ImportError:
+    YAML_AVAILABLE = False
+
+
+def _load_yaml_file(file_path: Path) -> Dict[str, Any]:
+    """Load a YAML file safely with fallback to empty dict.
+
+    Args:
+        file_path: Path to the YAML file
+
+    Returns:
+        Parsed YAML content or empty dict on failure
+    """
+    if not file_path.exists():
+        return {}
+    if not YAML_AVAILABLE:
+        return {}
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception:
+        return {}
+
+
+def _merge_configs(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    """Recursively merge two configuration dictionaries.
+
+    Args:
+        base: Base configuration dictionary
+        override: Override configuration dictionary
+
+    Returns:
+        Merged configuration dictionary
+    """
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _merge_configs(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from section YAML files with fallbacks.
+
+    Priority:
+    1. Section files (.moai/config/sections/*.yaml)
+    2. Main config.yaml
+    3. Legacy config.json
+
+    Returns:
+        Configuration dictionary or dict with 'error' key if not found
+    """
+    config_dir = Path(".moai/config")
+    sections_dir = config_dir / "sections"
+
+    config: Dict[str, Any] = {}
+
+    # Try section-based configuration first (new approach)
+    if sections_dir.exists() and sections_dir.is_dir():
+        section_files = [
+            ("language.yaml", "language"),
+            ("user.yaml", "user"),
+            ("project.yaml", "project"),
+            ("system.yaml", "system"),
+            ("git-strategy.yaml", "git_strategy"),
+            ("quality.yaml", "quality"),
+        ]
+        for filename, _key in section_files:
+            section_path = sections_dir / filename
+            section_data = _load_yaml_file(section_path)
+            if section_data:
+                config = _merge_configs(config, section_data)
+        if config:
+            return config
+
+    # Fallback to main config.yaml
+    yaml_config_path = config_dir / "config.yaml"
+    if yaml_config_path.exists() and YAML_AVAILABLE:
+        try:
+            with open(yaml_config_path, "r", encoding="utf-8") as f:
+                config = yaml.safe_load(f) or {}
+                if config:
+                    return config
+        except Exception:
+            pass
+
+    # Legacy fallback to config.json
+    json_config_path = config_dir / "config.json"
+    if json_config_path.exists():
+        try:
+            with open(json_config_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except json.JSONDecodeError as e:
+            return {"error": f"JSON decode error: {e}"}
+        except Exception as e:
+            return {"error": f"File read error: {e}"}
+
+    return {"error": "Configuration file not found"}
+
+
+def validate_language_config(config: Dict[str, Any]) -> Dict[str, Any]:
+    """Validate language configuration
+
+    Args:
+        config: Configuration dictionary
+
+    Returns:
+        Validation result with status and details
+    """
+    warnings: List[str] = []
+    errors: List[str] = []
+    result: Dict[str, Any] = {
+        "valid": True,
+        "warnings": warnings,
+        "errors": errors,
+        "language_info": {},
+    }
+
+    # Check if language section exists
+    if "language" not in config:
+        result["valid"] = False
+        errors.append("Missing 'language' configuration section")
+        return result
+
+    lang_config = config.get("language", {})
+
+    # Validate conversation_language
+    conversation_lang = lang_config.get("conversation_language", "en")
+    if not conversation_lang:
+        result["valid"] = False
+        errors.append("conversation_language is empty or missing")
+    elif conversation_lang not in ["ko", "en", "ja", "zh"]:
+        warnings.append(
+            f"conversation_language '{conversation_lang}' is not officially supported (supported: ko, en, ja, zh)"
+        )
+
+    # Validate conversation_language_name
+    lang_name = lang_config.get("conversation_language_name", "")
+    if not lang_name:
+        result["valid"] = False
+        errors.append("conversation_language_name is empty or missing")
+    elif conversation_lang == "ko" and lang_name != "Korean":
+        warnings.append(f"conversation_language_name '{lang_name}' doesn't match 'Korean' for Korean language")
+    elif conversation_lang == "en" and lang_name != "English":
+        warnings.append(f"conversation_language_name '{lang_name}' doesn't match 'English' for English language")
+    elif conversation_lang == "ja" and lang_name != "Japanese":
+        warnings.append(f"conversation_language_name '{lang_name}' doesn't match 'Japanese' for Japanese language")
+    elif conversation_lang == "zh" and lang_name != "Chinese":
+        warnings.append(f"conversation_language_name '{lang_name}' doesn't match 'Chinese' for Chinese language")
+
+    # Validate agent_prompt_language
+    agent_lang = lang_config.get("agent_prompt_language", conversation_lang)
+    if agent_lang != conversation_lang:
+        warnings.append(
+            f"agent_prompt_language '{agent_lang}' differs from conversation_language '{conversation_lang}'"
+        )
+
+    # Store language info
+    result["language_info"] = {
+        "conversation_language": conversation_lang,
+        "conversation_language_name": lang_name,
+        "agent_prompt_language": agent_lang,
+        "primary_language": conversation_lang,
+        "is_korean": conversation_lang == "ko",
+        "is_english": conversation_lang == "en",
+        "is_japanese": conversation_lang == "ja",
+        "is_chinese": conversation_lang == "zh",
+        "is_multilingual": conversation_lang in ["ko", "ja", "zh"],
+    }
+
+    return result
+
+
+def validate_output_style_compatibility() -> Dict[str, Any]:
+    """Validate if output style supports language configuration
+
+    Returns:
+        Compatibility check results
+    """
+    recommendations: List[str] = []
+    result: Dict[str, Any] = {
+        "r2d2_exists": False,
+        "language_support_present": False,
+        "config_reading_present": False,
+        "recommendations": recommendations,
+    }
+
+    # Check if R2-D2 output style exists
+    r2d2_path = Path(".claude/output-styles/moai/r2d2.md")
+    result["r2d2_exists"] = r2d2_path.exists()
+
+    if r2d2_path.exists():
+        try:
+            with open(r2d2_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Check for language support indicators
+            language_keywords = [
+                "conversation_language",
+                "language.conversation_language",
+                "한국어",
+                "Korean",
+                "Language Configuration",
+            ]
+
+            result["language_support_present"] = any(keyword in content for keyword in language_keywords)
+            # Check for config reading (supports both YAML sections and legacy JSON)
+            result["config_reading_present"] = (
+                ".moai/config/sections" in content
+                or ".moai/config/config.yaml" in content
+                or ".moai/config/config.json" in content
+            )
+
+            if not result["language_support_present"]:
+                recommendations.append("Add language support documentation to R2-D2 output style")
+
+            if not result["config_reading_present"]:
+                recommendations.append("Add config.json reading instructions to R2-D2 output style")
+
+        except Exception as e:
+            result["error"] = f"Error reading R2-D2 output style: {e}"
+    else:
+        recommendations.append("R2-D2 output style not found - ensure proper installation")
+
+    return result
+
+
+def validate_session_start_hook() -> Dict[str, Any]:
+    """Validate if SessionStart hook displays language info
+
+    Returns:
+        Hook validation results
+    """
+    recommendations: List[str] = []
+    result: Dict[str, Any] = {
+        "hook_exists": False,
+        "language_display_present": False,
+        "recommendations": recommendations,
+    }
+
+    hook_path = Path(".claude/hooks/moai/session_start__show_project_info.py")
+    result["hook_exists"] = hook_path.exists()
+
+    if hook_path.exists():
+        try:
+            with open(hook_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Check for language display functionality
+            language_indicators = [
+                "get_language_info",
+                "conversation_language",
+                "language_name",
+                "Language:",
+            ]
+
+            result["language_display_present"] = any(indicator in content for indicator in language_indicators)
+
+            if not result["language_display_present"]:
+                recommendations.append("Add language info display to SessionStart hook")
+
+        except Exception as e:
+            result["error"] = f"Error reading SessionStart hook: {e}"
+    else:
+        recommendations.append("SessionStart hook not found - ensure proper installation")
+
+    return result
+
+
+def generate_validation_report() -> str:
+    """Generate comprehensive language validation report
+
+    Returns:
+        Formatted validation report string
+    """
+    report_lines = ["🌐 Language Configuration Validation Report", "=" * 50]
+
+    # Load and validate config
+    config = load_config()
+    if "error" in config:
+        report_lines.append(f"❌ Config Error: {config['error']}")
+        return "\n".join(report_lines)
+
+    validation = validate_language_config(config)
+    language_info = validation["language_info"]
+
+    # Current configuration status
+    report_lines.extend(
+        [
+            "",
+            "📋 Current Configuration:",
+            f"  • Language: {language_info.get('conversation_language_name', 'Unknown')} "
+            f"({language_info.get('conversation_language', 'Unknown')})",
+            f"  • Agent Language: {language_info.get('agent_prompt_language', 'Unknown')}",
+            f"  • Korean Mode: {'✅ Active' if language_info.get('is_korean') else '❌ Inactive'}",
+            f"  • Config Valid: {'✅ Valid' if validation['valid'] else '❌ Invalid'}",
+        ]
+    )
+
+    # Errors and warnings
+    if validation["errors"]:
+        report_lines.extend(["", "❌ Errors:"])
+        for error in validation["errors"]:
+            report_lines.append(f"  • {error}")
+
+    if validation["warnings"]:
+        report_lines.extend(["", "⚠️ Warnings:"])
+        for warning in validation["warnings"]:
+            report_lines.append(f"  • {warning}")
+
+    # Output style compatibility
+    report_lines.extend(["", "🔧 Output Style Compatibility:"])
+    output_check = validate_output_style_compatibility()
+    report_lines.extend(
+        [
+            f"  • R2-D2 Output Style: {'✅ Found' if output_check['r2d2_exists'] else '❌ Missing'}",
+            f"  • Language Support: {'✅ Present' if output_check['language_support_present'] else '❌ Missing'}",
+            f"  • Config Reading: {'✅ Present' if output_check['config_reading_present'] else '❌ Missing'}",
+        ]
+    )
+
+    if output_check.get("recommendations"):
+        report_lines.extend(["", "  Recommendations:"])
+        for rec in output_check["recommendations"]:
+            report_lines.append(f"    • {rec}")
+
+    # SessionStart hook check
+    report_lines.extend(["", "🎣 SessionStart Hook:"])
+    hook_check = validate_session_start_hook()
+    report_lines.extend(
+        [
+            f"  • Hook Exists: {'✅ Found' if hook_check['hook_exists'] else '❌ Missing'}",
+            f"  • Language Display: {'✅ Present' if hook_check['language_display_present'] else '❌ Missing'}",
+        ]
+    )
+
+    if hook_check.get("recommendations"):
+        report_lines.extend(["", "  Recommendations:"])
+        for rec in hook_check["recommendations"]:
+            report_lines.append(f"    • {rec}")
+
+    # Overall status
+    report_lines.extend(["", "📊 Overall Status:"])
+    all_good = (
+        validation["valid"]
+        and not validation["errors"]
+        and output_check["r2d2_exists"]
+        and output_check["language_support_present"]
+        and hook_check["hook_exists"]
+        and hook_check["language_display_present"]
+    )
+
+    if all_good:
+        report_lines.append("✅ Language configuration is fully functional!")
+        if language_info.get("is_korean"):
+            report_lines.append("🇰🇷 Korean language responses should work correctly.")
+        else:
+            report_lines.append("🌐 English language responses configured.")
+    else:
+        report_lines.append("⚠️ Issues found that may prevent proper language functionality.")
+        report_lines.append("   See recommendations above for fixes.")
+
+    return "\n".join(report_lines)
+
+
+def main() -> None:
+    """Main entry point for language configuration validator"""
+    try:
+        report = generate_validation_report()
+        print(report)
+
+        # Exit with appropriate code
+        config = load_config()
+        if "error" in config:
+            sys.exit(2)  # Config error
+        else:
+            validation = validate_language_config(config)
+            if not validation["valid"]:
+                sys.exit(1)  # Config invalid
+            else:
+                sys.exit(0)  # Success
+
+    except Exception as e:
+        print(f"❌ Language validation error: {e}")
+        sys.exit(3)
+
+
+if __name__ == "__main__":
+    main()

moai_adk/templates/.claude/hooks/moai/lib/models.py

@@ -0,0 +1,104 @@
+"""
+Hook model classes - Data structures for hook payloads and results.
+
+Provides HookPayload and HookResult classes used by hook handlers
+to process events and return execution results to Claude Code.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Any
+
+
+class HookPayload(dict):
+    """
+    A dictionary subclass for hook event payloads.
+
+    Provides dict-like access to hook event data with .get() method support.
+    Used to pass event data from Claude Code to hook handlers.
+
+    Example:
+        payload = HookPayload({
+            "tool": "Read",
+            "cwd": "/path/to/project",
+            "userPrompt": "Read the file"
+        })
+
+        tool_name = payload.get("tool", "")
+        working_dir = payload.get("cwd", ".")
+    """
+
+    def __init__(self, data: dict[str, Any] | None = None):
+        """Initialize HookPayload with optional data dictionary."""
+        super().__init__(data or {})
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get value from payload with optional default."""
+        return super().get(key, default)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """Set value in payload."""
+        super().__setitem__(key, value)
+
+    def update(self, other: dict[str, Any]) -> None:  # type: ignore[override]
+        """Update payload with another dictionary."""
+        super().update(other)
+
+
+@dataclass
+class HookResult:
+    """
+    A class representing the result of a hook execution.
+
+    Used by hook handlers to return execution results, messages, and metadata
+    back to Claude Code. Supports JSON serialization via to_dict() method.
+
+    Attributes:
+        system_message (Optional[str]): Message to display to user
+        continue_execution (bool): Whether to continue execution (default: True)
+        context_files (List[str]): List of context file paths to load
+        hook_specific_output (Optional[Dict[str, Any]]): Hook-specific data
+        block_execution (bool): Whether to block execution (default: False)
+
+    Example:
+        # Simple result with just a message
+        return HookResult(system_message="Operation completed")
+
+        # Result with context files
+        return HookResult(
+            system_message="Loaded 3 context files",
+            context_files=["README.md", "config.json"]
+        )
+
+        # Result that stops execution
+        return HookResult(
+            system_message="Dangerous operation blocked",
+            continue_execution=False,
+            block_execution=True
+        )
+    """
+
+    system_message: str | None = None
+    continue_execution: bool = True
+    context_files: list[str] = None  # type: ignore[assignment]
+    hook_specific_output: dict[str, Any] | None = None
+    block_execution: bool = False
+
+    def __post_init__(self):
+        """Post-initialization to set default values."""
+        if self.context_files is None:
+            self.context_files = []
+        if self.hook_specific_output is None:
+            self.hook_specific_output = {}
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Convert HookResult to a dictionary for JSON serialization.
+
+        Returns:
+            Dict[str, Any]: Dictionary representation of the HookResult
+        """
+        result = asdict(self)
+        # Remove empty/None values to keep output clean
+        return {k: v for k, v in result.items() if v or v is False or v == 0}