moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

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

@@ -0,0 +1,376 @@
+# type: ignore
+"""
+Statusline configuration loader for Claude Code
+
+Loads and manages statusline configuration from .moai/config/statusline-config.yaml
+
+Performance: Thread-safe singleton with double-checked locking pattern
+"""
+
+import logging
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CacheConfig:
+    """Cache TTL configuration"""
+
+    git_ttl_seconds: int = 5
+    metrics_ttl_seconds: int = 10
+    alfred_ttl_seconds: int = 1
+    todo_ttl_seconds: int = 3
+    memory_ttl_seconds: int = 5
+    output_style_ttl_seconds: int = 60
+    version_ttl_seconds: int = 60
+    update_ttl_seconds: int = 300
+
+
+@dataclass
+class ColorConfig:
+    """Color configuration"""
+
+    enabled: bool = True
+    theme: str = "auto"  # auto | light | dark | high-contrast
+    palette: Dict[str, str] = None
+
+    def __post_init__(self):
+        if self.palette is None:
+            self.palette = {
+                "model": "38;5;33",  # Blue
+                "output_style": "38;5;219",  # Pink/Magenta
+                "feature_branch": "38;5;226",  # Yellow
+                "develop_branch": "38;5;51",  # Cyan
+                "main_branch": "38;5;46",  # Green
+                "staged": "38;5;46",  # Green
+                "modified": "38;5;208",  # Orange
+                "untracked": "38;5;196",  # Red
+                "update_available": "38;5;208",  # Orange
+                "memory_usage": "38;5;172",  # Brown/Orange
+                "duration": "38;5;240",  # Gray
+                "todo_count": "38;5;123",  # Purple
+                "separator": "38;5;250",  # Light Gray
+            }
+
+
+@dataclass
+class DisplayConfig:
+    """Information display settings - Custom ordered status bar"""
+
+    model: bool = True  # 🤖 Model name (glm-4.6, claude-3.5-sonnet, etc.)
+    version: bool = True  # 🗿 MoAI-ADK version (0.23.0, etc.)
+    output_style: bool = True  # ✍️ Output style (Explanatory, Concise, etc.)
+    memory_usage: bool = True  # 💾 Session memory usage
+    todo_count: bool = True  # 📋 Active TODO items count
+    branch: bool = True  # 🔀 Git branch
+    git_status: bool = True  # ✅2 M1 ?10 Git changes status
+    duration: bool = True  # ⏱️ Session elapsed time
+    directory: bool = True  # 📁 Project name/directory
+    active_task: bool = True  # 🎯 Alfred active task
+    update_indicator: bool = True  # 🔄 Update notification
+
+
+@dataclass
+class FormatConfig:
+    """Format configuration"""
+
+    max_branch_length: int = 20
+    truncate_with: str = "..."
+    separator: str = " | "
+
+    # Icon configuration for better visual recognition
+    icons: Dict[str, str] = None
+
+    def __post_init__(self):
+        if self.icons is None:
+            self.icons = {
+                "git": "🔀",  # Git branch icon (more intuitive than 📊)
+                "staged": "✅",  # Staged files
+                "modified": "📝",  # Modified files
+                "untracked": "❓",  # Untracked files
+                "added": "➕",  # Added files
+                "deleted": "➖",  # Deleted files
+                "renamed": "🔄",  # Renamed files
+                "conflict": "⚠️",  # Conflict files
+                "model": "🤖",  # AI model
+                "output_style": "✍️",  # Writing style
+                "duration": "⏱️",  # Time duration
+                "memory": "💾",  # Memory usage
+                "todo": "📋",  # TODO items
+                "update": "🔄",  # Update available
+                "project": "📁",  # Project directory
+            }
+
+
+@dataclass
+class ErrorHandlingConfig:
+    """Error handling configuration"""
+
+    graceful_degradation: bool = True
+    log_level: str = "warning"  # warning | error
+    fallback_text: str = ""
+
+
+class StatuslineConfig:
+    """
+    Thread-safe singleton configuration loader for statusline
+
+    Loads configuration from .moai/config/statusline-config.yaml
+    Falls back to default values if file not found or parsing fails
+
+    Performance: Double-checked locking pattern for thread safety
+    """
+
+    _instance: Optional["StatuslineConfig"] = None
+    _config: Dict[str, Any] = {}
+    _lock = threading.Lock()  # Thread-safe singleton lock
+
+    def __new__(cls):
+        # Double-checked locking pattern for thread-safe singleton
+        if cls._instance is None:
+            with cls._lock:
+                # Double-check after acquiring lock
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._load_config()
+        return cls._instance
+
+    def _load_config(self) -> None:
+        """Load configuration from YAML file"""
+        config_path = self._find_config_file()
+
+        if config_path and config_path.exists():
+            try:
+                self._config = self._parse_yaml(config_path)
+                logger.debug(f"Loaded statusline config from {config_path}")
+            except Exception as e:
+                logger.warning(f"Failed to load config from {config_path}: {e}")
+                self._config = self._get_default_config()
+        else:
+            logger.debug("Statusline config file not found, using defaults")
+            self._config = self._get_default_config()
+
+    @staticmethod
+    def _find_config_file() -> Optional[Path]:
+        """
+        Find statusline config file starting from current directory up to project root
+
+        Returns:
+            Path to config file or None if not found
+        """
+        # Try common locations
+        locations = [
+            Path.cwd() / ".moai" / "config" / "statusline-config.yaml",
+            Path.cwd() / ".moai" / "config" / "statusline-config.yml",
+            Path.home() / ".moai" / "config" / "statusline-config.yaml",
+        ]
+
+        for path in locations:
+            if path.exists():
+                return path
+
+        return None
+
+    @staticmethod
+    def _parse_yaml(path: Path) -> Dict[str, Any]:
+        """
+        Parse YAML file
+
+        Args:
+            path: Path to YAML file
+
+        Returns:
+            Parsed configuration dictionary
+        """
+        try:
+            import yaml
+
+            with open(path, "r", encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            return data or {}
+        except ImportError:
+            logger.debug("PyYAML not available, attempting JSON fallback")
+            return StatuslineConfig._parse_json_fallback(path)
+
+    @staticmethod
+    def _parse_json_fallback(path: Path) -> Dict[str, Any]:
+        """
+        Parse YAML as JSON fallback (limited support)
+
+        Args:
+            path: Path to file
+
+        Returns:
+            Parsed configuration dictionary
+        """
+        import json
+
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            logger.debug(f"JSON fallback failed: {e}")
+            return {}
+
+    @staticmethod
+    def _get_default_config() -> Dict[str, Any]:
+        """
+        Get default configuration
+
+        Returns:
+            Default configuration dictionary
+        """
+        return {
+            "statusline": {
+                "enabled": True,
+                "mode": "extended",
+                "refresh_interval_ms": 300,
+                "colors": {
+                    "enabled": True,
+                    "theme": "auto",
+                    "palette": {
+                        "model": "38;5;33",
+                        "feature_branch": "38;5;226",
+                        "develop_branch": "38;5;51",
+                        "main_branch": "38;5;46",
+                        "staged": "38;5;46",
+                        "modified": "38;5;208",
+                        "untracked": "38;5;196",
+                        "update_available": "38;5;208",
+                    },
+                },
+                "cache": {
+                    "git_ttl_seconds": 5,
+                    "metrics_ttl_seconds": 10,
+                    "alfred_ttl_seconds": 1,
+                    "todo_ttl_seconds": 3,
+                    "memory_ttl_seconds": 5,
+                    "output_style_ttl_seconds": 60,
+                    "version_ttl_seconds": 60,
+                    "update_ttl_seconds": 300,
+                },
+                "display": {
+                    "model": True,  # 🤖 Model name (glm-4.6, claude-3.5-sonnet, etc.)
+                    "version": True,  # 🗿 MoAI-ADK version (0.23.0, etc.)
+                    "output_style": True,  # ✍️ Output style (Explanatory, Concise, etc.)
+                    "memory_usage": True,  # 💾 Session memory usage
+                    "todo_count": True,  # 📋 Active TODO items count
+                    "branch": True,  # 🔀 Git branch
+                    "git_status": True,  # ✅2 M1 ?10 Git changes status
+                    "duration": True,  # ⏱️ Session elapsed time
+                    "directory": True,  # 📁 Project name/directory
+                    "active_task": True,  # 🎯 Alfred active task
+                    "update_indicator": True,  # 🔄 Update notification
+                },
+                "error_handling": {
+                    "graceful_degradation": True,
+                    "log_level": "warning",
+                    "fallback_text": "",
+                },
+                "format": {
+                    "max_branch_length": 20,
+                    "truncate_with": "...",
+                    "separator": " | ",
+                    "icons": {
+                        "git": "🔀",  # Git branch icon (more intuitive than 📊)
+                        "staged": "✅",  # Staged files
+                        "modified": "📝",  # Modified files
+                        "untracked": "❓",  # Untracked files
+                        "added": "➕",  # Added files
+                        "deleted": "➖",  # Deleted files
+                        "renamed": "🔄",  # Renamed files
+                        "conflict": "⚠️",  # Conflict files
+                        "model": "🤖",  # AI model
+                        "output_style": "✍️",  # Writing style
+                        "duration": "⏱️",  # Time duration
+                        "memory": "💾",  # Memory usage
+                        "todo": "📋",  # TODO items
+                        "update": "🔄",  # Update available
+                        "project": "📁",  # Project directory
+                    },
+                },
+            }
+        }
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value by dot-notation key
+
+        Args:
+            key: Configuration key (e.g., "statusline.mode", "statusline.cache.git_ttl_seconds")
+            default: Default value if key not found
+
+        Returns:
+            Configuration value or default
+        """
+        keys = key.split(".")
+        value = self._config
+
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+                if value is None:
+                    return default
+            else:
+                return default
+
+        return value if value is not None else default
+
+    def get_cache_config(self) -> CacheConfig:
+        """Get cache configuration"""
+        cache_data = self.get("statusline.cache", {})
+        return CacheConfig(
+            git_ttl_seconds=cache_data.get("git_ttl_seconds", 5),
+            metrics_ttl_seconds=cache_data.get("metrics_ttl_seconds", 10),
+            alfred_ttl_seconds=cache_data.get("alfred_ttl_seconds", 1),
+            version_ttl_seconds=cache_data.get("version_ttl_seconds", 60),
+            update_ttl_seconds=cache_data.get("update_ttl_seconds", 300),
+        )
+
+    def get_color_config(self) -> ColorConfig:
+        """Get color configuration"""
+        color_data = self.get("statusline.colors", {})
+        return ColorConfig(
+            enabled=color_data.get("enabled", True),
+            theme=color_data.get("theme", "auto"),
+            palette=color_data.get("palette", {}),
+        )
+
+    def get_display_config(self) -> DisplayConfig:
+        """Get display configuration"""
+        display_data = self.get("statusline.display", {})
+        return DisplayConfig(
+            model=display_data.get("model", True),
+            version=display_data.get("version", True),
+            output_style=display_data.get("output_style", True),
+            memory_usage=display_data.get("memory_usage", True),
+            todo_count=display_data.get("todo_count", True),
+            branch=display_data.get("branch", True),
+            git_status=display_data.get("git_status", True),
+            duration=display_data.get("duration", True),
+            directory=display_data.get("directory", True),
+            active_task=display_data.get("active_task", True),
+            update_indicator=display_data.get("update_indicator", True),
+        )
+
+    def get_format_config(self) -> FormatConfig:
+        """Get format configuration"""
+        format_data = self.get("statusline.format", {})
+        return FormatConfig(
+            max_branch_length=format_data.get("max_branch_length", 20),
+            truncate_with=format_data.get("truncate_with", "..."),
+            separator=format_data.get("separator", " | "),
+        )
+
+    def get_error_handling_config(self) -> ErrorHandlingConfig:
+        """Get error handling configuration"""
+        error_data = self.get("statusline.error_handling", {})
+        return ErrorHandlingConfig(
+            graceful_degradation=error_data.get("graceful_degradation", True),
+            log_level=error_data.get("log_level", "warning"),
+            fallback_text=error_data.get("fallback_text", ""),
+        )

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

@@ -6,7 +6,7 @@ Provides centralized configuration management with fallbacks and validation.
 
 import json
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict
 
 try:
     import yaml
@@ -15,6 +15,7 @@ try:
 except ImportError:
     YAML_AVAILABLE = False
 
+from .atomic_write import atomic_write_json
 from .path_utils import find_project_root
 
 # Default configuration
@@ -73,7 +74,7 @@ DEFAULT_CONFIG = {
 class ConfigManager:
     """Configuration manager for Alfred hooks with validation and fallbacks."""
 
-    def __init__(self, config_path: Optional[Path] = None):
+    def __init__(self, config_path: Path | None = None):
         """Initialize configuration manager.
 
         Args:
@@ -95,7 +96,7 @@ class ConfigManager:
                 # Default to YAML for new projects
                 self.config_path = yaml_path if YAML_AVAILABLE else json_path
 
-        self._config: Optional[Dict[str, Any]] = None
+        self._config: Dict[str, Any] | None = None
 
     def load_config(self) -> Dict[str, Any]:
         """Load configuration from file with fallback to defaults.
@@ -121,14 +122,16 @@ class ConfigManager:
                     else:
                         file_config = json.load(f)
                         config = self._merge_configs(DEFAULT_CONFIG.copy(), file_config)
-            except (
-                json.JSONDecodeError,
-                yaml.YAMLError if YAML_AVAILABLE else Exception,
-                IOError,
-                OSError,
-            ):
+            except (json.JSONDecodeError, IOError, OSError):
                 # Use defaults if file is corrupted or unreadable
                 config = DEFAULT_CONFIG.copy()
+            except Exception as e:
+                # Handle YAML errors or other parsing issues
+                if YAML_AVAILABLE and isinstance(e, yaml.YAMLError):
+                    config = DEFAULT_CONFIG.copy()
+                else:
+                    # Re-raise unexpected exceptions
+                    raise
         else:
             # Use defaults if file doesn't exist
             config = DEFAULT_CONFIG.copy()
@@ -295,7 +298,7 @@ class ConfigManager:
         exit_codes = self.get("hooks.exit_codes", {})
         return exit_codes.get(code_type, 0)
 
-    def update_config(self, updates: Dict[str, Any]) -> bool:
+    def update_config(self, updates: dict[str, Any]) -> bool:
         """Update configuration and save to file.
 
         Args:
@@ -311,12 +314,9 @@ class ConfigManager:
             # Merge updates
             updated = self._merge_configs(current, updates)
 
-            # Create parent directory if needed
-            self.config_path.parent.mkdir(parents=True, exist_ok=True)
-
-            # Write updated config
-            with open(self.config_path, "w", encoding="utf-8") as f:
-                json.dump(updated, f, indent=2)
+            # Write updated config using atomic write (H3)
+            # atomic_write_json will create parent directories if needed
+            atomic_write_json(self.config_path, updated, indent=2)
 
             # Clear cache to force reload
             self._config = None
@@ -339,9 +339,11 @@ class ConfigManager:
 
         return True
 
-    def _merge_configs(self, base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    def _merge_configs(self, base: dict[str, Any], override: dict[str, Any]) -> Dict[str, Any]:
         """Recursively merge two configuration dictionaries.
 
+        This method delegates to common.merge_configs() for consistent behavior.
+
         Args:
             base: Base configuration dictionary
             override: Override configuration dictionary
@@ -349,22 +351,16 @@ class ConfigManager:
         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] = self._merge_configs(result[key], value)
-            else:
-                result[key] = value
+        from .common import merge_configs
 
-        return result
+        return merge_configs(base, override)
 
 
 # Module-level helper functions
-_config_manager: Optional[ConfigManager] = None
+_config_manager: ConfigManager | None = None
 
 
-def get_config_manager(config_path: Optional[Path] = None) -> ConfigManager:
+def get_config_manager(config_path: Path | None = None) -> ConfigManager:
     """Get or create a ConfigManager instance.
 
     Args:
@@ -379,7 +375,7 @@ def get_config_manager(config_path: Optional[Path] = None) -> ConfigManager:
     return _config_manager
 
 
-def get_config(key_path: str = "", config_path: Optional[Path] = None) -> Any:
+def get_config(key_path: str = "", config_path: Path | None = None) -> Any:
     """Get configuration value.
 
     Args:

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

@@ -17,7 +17,7 @@ import logging
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Tuple
 
 
 class ValidationLevel(Enum):
@@ -36,8 +36,8 @@ class ValidationIssue:
     level: ValidationLevel
     path: str
     message: str
-    suggestion: Optional[str] = None
-    current_value: Optional[str] = None
+    suggestion: str | None = None
+    current_value: str | None = None
 
 
 @dataclass
@@ -109,7 +109,7 @@ class ConfigurationValidator:
             },
         }
 
-    def validate_config(self, config: Dict[str, Any]) -> Tuple[bool, List[ValidationIssue]]:
+    def validate_config(self, config: dict[str, Any]) -> Tuple[bool, List[ValidationIssue]]:
         """Validate complete configuration and return issues"""
         issues = []
 
@@ -135,7 +135,7 @@ class ConfigurationValidator:
         is_valid = not any(issue.level in [ValidationLevel.ERROR, ValidationLevel.CRITICAL] for issue in issues)
         return is_valid, issues
 
-    def _validate_structure(self, config: Dict[str, Any]) -> List[ValidationIssue]:
+    def _validate_structure(self, config: dict[str, Any]) -> List[ValidationIssue]:
         """Validate top-level configuration structure"""
         issues = []
 
@@ -159,7 +159,7 @@ class ConfigurationValidator:
 
         return issues
 
-    def _validate_timeout_manager(self, timeout_config: Dict[str, Any]) -> List[ValidationIssue]:
+    def _validate_timeout_manager(self, timeout_config: dict[str, Any]) -> List[ValidationIssue]:
         """Validate timeout manager configuration"""
         issues = []
         base_path = ".timeout_manager"
@@ -238,7 +238,7 @@ class ConfigurationValidator:
 
         return issues
 
-    def _validate_hook_configs(self, hook_configs: Dict[str, Any]) -> List[ValidationIssue]:
+    def _validate_hook_configs(self, hook_configs: dict[str, Any]) -> List[ValidationIssue]:
         """Validate hook-specific configurations"""
         issues = []
         base_path = ".hook_configs"
@@ -249,7 +249,7 @@ class ConfigurationValidator:
 
         return issues
 
-    def _validate_single_hook_config(self, hook_name: str, config: Dict[str, Any], path: str) -> List[ValidationIssue]:
+    def _validate_single_hook_config(self, hook_name: str, config: dict[str, Any], path: str) -> List[ValidationIssue]:
         """Validate configuration for a single hook"""
         issues = []
 
@@ -360,7 +360,7 @@ class ConfigurationValidator:
 
         return issues
 
-    def _validate_resources(self, resource_config: Dict[str, Any]) -> List[ValidationIssue]:
+    def _validate_resources(self, resource_config: dict[str, Any]) -> List[ValidationIssue]:
         """Validate resource configuration"""
         issues = []
         base_path = ".resources"
@@ -422,7 +422,7 @@ class ConfigurationValidator:
 
         return issues
 
-    def _validate_performance(self, performance_config: Dict[str, Any]) -> List[ValidationIssue]:
+    def _validate_performance(self, performance_config: dict[str, Any]) -> List[ValidationIssue]:
         """Validate performance-related configuration"""
         issues = []
         base_path = ".performance"
@@ -474,7 +474,7 @@ class ConfigurationValidator:
         policy_timeouts = {"fast": 2000, "normal": 5000, "slow": 15000, "custom": 5000}
         return policy_timeouts.get(policy, 5000)
 
-    def normalize_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+    def normalize_config(self, config: dict[str, Any]) -> Dict[str, Any]:
         """Normalize and apply defaults to configuration"""
         normalized = config.copy()
 
@@ -534,7 +534,7 @@ class ConfigurationValidator:
 
         return normalized
 
-    def generate_report(self, issues: List[ValidationIssue]) -> str:
+    def generate_report(self, issues: list[ValidationIssue]) -> str:
         """Generate human-readable validation report"""
         if not issues:
             return "✅ Configuration validation passed with no issues found."
@@ -542,7 +542,7 @@ class ConfigurationValidator:
         lines = ["📋 Configuration Validation Report", ""]
 
         # Group issues by severity
-        by_level: Dict[ValidationLevel, List[ValidationIssue]] = {}
+        by_level: dict[ValidationLevel, List[ValidationIssue]] = {}
         for issue in issues:
             if issue.level not in by_level:
                 by_level[issue.level] = []
@@ -616,7 +616,7 @@ def get_config_validator() -> ConfigurationValidator:
 
 # Convenience functions
 def validate_hook_config(
-    config_path: Optional[Path] = None,
+    config_path: Path | None = None,
 ) -> Tuple[bool, List[ValidationIssue]]:
     """Validate hooks configuration"""
     validator = get_config_validator()