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

moai_adk/core/config/unified.py

@@ -13,13 +13,20 @@ Features:
 - Deep merge for nested configs
 - Configuration migration between versions
 - Domain-specific facades for different subsystems
+- Modular section-based YAML configuration (new in v0.36.0)
 
 Design Philosophy:
-- Single source of truth for `.moai/config/config.yaml` (with JSON fallback)
+- Primary: Modular section files `.moai/config/sections/*.yaml`
+- Fallback: Legacy monolithic `.moai/config/config.yaml` or `config.json`
 - Best patterns from StatuslineConfig, UnifiedConfigManager, ConfigurationManager
 - Backward compatible with existing ConfigManager interfaces
 - Performance optimized with caching and minimal I/O
 
+Configuration Architecture:
+- New projects: Modular sections (language.yaml, user.yaml, project.yaml, etc.)
+- Legacy projects: Monolithic config.json/config.yaml (auto-migrated on update)
+- Priority: Section files override monolithic config if both exist
+
 Usage:
     >>> from moai_adk.core.config.unified import get_unified_config
     >>> config = get_unified_config()
@@ -95,62 +102,59 @@ class UnifiedConfigManager:
         Initialize configuration manager (called once by singleton).
 
         Args:
-            config_path: Optional path to config file
+            config_path: Optional path to config file (legacy mode) or sections directory
         """
         # Set config path with auto-detection
         if config_path:
             self._config_path = Path(config_path)
         else:
-            # Auto-detect YAML (preferred) or JSON (fallback)
+            # Auto-detect configuration strategy
             base_path = Path.cwd() / ".moai" / "config"
-            yaml_path = base_path / "config.yaml"
-            json_path = base_path / "config.json"
+            sections_dir = base_path / "sections"
 
-            if YAML_AVAILABLE and yaml_path.exists():
-                self._config_path = yaml_path
-            elif json_path.exists():
-                self._config_path = json_path
+            # Priority 1: Section-based configuration (new approach)
+            if sections_dir.exists() and sections_dir.is_dir():
+                self._config_path = sections_dir
             else:
-                # Default to YAML for new projects
-                self._config_path = yaml_path if YAML_AVAILABLE else json_path
+                # Priority 2: Monolithic YAML (legacy)
+                yaml_path = base_path / "config.yaml"
+                json_path = base_path / "config.json"
+
+                if YAML_AVAILABLE and yaml_path.exists():
+                    self._config_path = yaml_path
+                elif json_path.exists():
+                    self._config_path = json_path
+                else:
+                    # Default to sections for new projects
+                    self._config_path = sections_dir if YAML_AVAILABLE else yaml_path
 
         # Load configuration
         self._load_config()
 
     def _load_config(self) -> None:
         """
-        Load configuration from file with caching.
+        Load configuration from file or sections with caching.
 
         Implements cache invalidation based on file modification time.
         Falls back to default configuration if file doesn't exist.
-        Supports both YAML (preferred) and JSON (legacy) formats.
+        Supports three modes:
+        1. Section-based YAML (new): Load from .moai/config/sections/*.yaml
+        2. Monolithic YAML (legacy): Load from .moai/config/config.yaml
+        3. Monolithic JSON (legacy): Load from .moai/config/config.json
         """
         try:
-            # Check if file exists
+            # Check if path exists
             if not self._config_path.exists():
-                logger.warning(f"Config file not found: {self._config_path}")
+                logger.warning(f"Config path not found: {self._config_path}")
                 self._config = self._get_default_config()
                 return
 
-            # Check cache validity
-            current_mtime = self._config_path.stat().st_mtime
-            if self._last_modified and current_mtime == self._last_modified:
-                # Cache is still valid
-                return
-
-            # Load from file (auto-detect format)
-            with open(self._config_path, "r", encoding="utf-8") as f:
-                if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
-                    if not YAML_AVAILABLE:
-                        raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
-                    self._config = yaml.safe_load(f) or {}
-                else:
-                    self._config = json.load(f)
-
-            # Update cache timestamp
-            self._last_modified = current_mtime
-
-            logger.debug(f"Loaded config from {self._config_path}")
+            # Section-based configuration (new approach)
+            if self._config_path.is_dir():
+                self._load_from_sections()
+            else:
+                # Monolithic configuration (legacy)
+                self._load_from_monolithic()
 
         except (
             json.JSONDecodeError,
@@ -161,6 +165,69 @@ class UnifiedConfigManager:
             logger.error(f"Failed to load config: {e}")
             self._config = self._get_default_config()
 
+    def _load_from_sections(self) -> None:
+        """
+        Load configuration from modular section YAML files.
+
+        Loads and merges all *.yaml files from sections directory:
+        - sections/language.yaml
+        - sections/user.yaml
+        - sections/project.yaml
+        - sections/system.yaml
+        - sections/git-strategy.yaml
+        - sections/quality.yaml
+        """
+        # Check cache validity (use directory mtime)
+        current_mtime = self._config_path.stat().st_mtime
+        if self._last_modified and current_mtime == self._last_modified:
+            # Cache is still valid
+            return
+
+        if not YAML_AVAILABLE:
+            raise ImportError("PyYAML is required for section-based config. Install with: pip install pyyaml")
+
+        # Merge all section files
+        merged_config: dict[str, Any] = {}
+        section_files = sorted(self._config_path.glob("*.yaml"))
+
+        for section_file in section_files:
+            try:
+                with open(section_file, "r", encoding="utf-8") as f:
+                    section_data = yaml.safe_load(f) or {}
+                    merged_config = self._deep_merge(merged_config, section_data)
+                    logger.debug(f"Loaded section: {section_file.name}")
+            except Exception as e:
+                logger.warning(f"Failed to load section {section_file.name}: {e}")
+
+        self._config = merged_config
+        self._last_modified = current_mtime
+        logger.debug(f"Loaded config from {len(section_files)} section files")
+
+    def _load_from_monolithic(self) -> None:
+        """
+        Load configuration from single monolithic file (legacy).
+
+        Supports both YAML and JSON formats.
+        """
+        # Check cache validity
+        current_mtime = self._config_path.stat().st_mtime
+        if self._last_modified and current_mtime == self._last_modified:
+            # Cache is still valid
+            return
+
+        # Load from file (auto-detect format)
+        with open(self._config_path, "r", encoding="utf-8") as f:
+            if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
+                if not YAML_AVAILABLE:
+                    raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
+                self._config = yaml.safe_load(f) or {}
+            else:
+                self._config = json.load(f)
+
+        # Update cache timestamp
+        self._last_modified = current_mtime
+        logger.debug(f"Loaded config from {self._config_path}")
+
     def get(self, key: str, default: Any = None) -> Any:
         """
         Get configuration value with dot-notation support.
@@ -238,7 +305,7 @@ class UnifiedConfigManager:
 
     def save(self, backup: bool = True) -> bool:
         """
-        Save configuration to file with atomic write.
+        Save configuration to file or sections with atomic write.
 
         Args:
             backup: If True, create backup before saving (default: True)
@@ -247,42 +314,130 @@ class UnifiedConfigManager:
             bool: True if save successful, False otherwise
 
         Pattern: Temp file → Atomic rename (prevents corruption)
+
+        Note: For section-based configs, saves to individual section files.
+              For monolithic configs, saves to single file.
         """
         try:
-            # Create backup if requested
-            if backup and self._config_path.exists():
-                self._create_backup()
+            # Section-based configuration
+            if self._config_path.is_dir():
+                return self._save_to_sections(backup)
+            else:
+                # Monolithic configuration (legacy)
+                return self._save_to_monolithic(backup)
 
-            # Atomic write pattern: temp file → rename
-            temp_path = self._config_path.with_suffix(".tmp")
+        except (OSError, PermissionError) as e:
+            logger.error(f"Failed to save config: {e}")
+            return False
+
+    def _save_to_sections(self, backup: bool) -> bool:
+        """
+        Save configuration to modular section YAML files.
+
+        Args:
+            backup: If True, create backup before saving
+
+        Returns:
+            bool: True if successful
+        """
+        if not YAML_AVAILABLE:
+            raise ImportError("PyYAML is required for section-based config. Install with: pip install pyyaml")
+
+        # Create backup if requested
+        if backup and self._config_path.exists():
+            self._create_backup()
+
+        # Define section mapping (top-level keys to section files)
+        section_mapping = {
+            "language": "language.yaml",
+            "user": "user.yaml",
+            "project": "project.yaml",
+            "moai": "system.yaml",
+            "github": "system.yaml",
+            "git": "git-strategy.yaml",
+            "quality": "quality.yaml",
+            "tdd": "quality.yaml",
+            "hooks": "system.yaml",
+            "session": "system.yaml",
+            # New in v1.1.0: Multi-LLM, pricing, and Ralph sections
+            "llm": "llm.yaml",
+            "pricing": "pricing.yaml",
+            "ralph": "ralph.yaml",
+            "service": "pricing.yaml",  # Alias for pricing
+            # Document management (from config.yaml)
+            "document_management": "system.yaml",
+        }
+
+        # Group config data by section file
+        section_data: Dict[str, Dict[str, Any]] = {}
+        for key, value in self._config.items():
+            section_file = section_mapping.get(key, "system.yaml")
+            if section_file not in section_data:
+                section_data[section_file] = {}
+            section_data[section_file][key] = value
+
+        # Write each section file atomically
+        for section_file, data in section_data.items():
+            section_path = self._config_path / section_file
+            temp_path = section_path.with_suffix(".tmp")
 
-            # Write to temp file (auto-detect format)
             with open(temp_path, "w", encoding="utf-8") as f:
-                if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
-                    if not YAML_AVAILABLE:
-                        raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
-                    yaml.safe_dump(
-                        self._config,
-                        f,
-                        default_flow_style=False,
-                        allow_unicode=True,
-                        sort_keys=False,
-                    )
-                else:
-                    json.dump(self._config, f, indent=2, ensure_ascii=False)
+                yaml.safe_dump(
+                    data,
+                    f,
+                    default_flow_style=False,
+                    allow_unicode=True,
+                    sort_keys=False,
+                )
 
             # Atomic rename
-            temp_path.replace(self._config_path)
+            temp_path.replace(section_path)
 
-            # Update cache timestamp
-            self._last_modified = self._config_path.stat().st_mtime
+        # Update cache timestamp
+        self._last_modified = self._config_path.stat().st_mtime
+        logger.info(f"Saved config to {len(section_data)} section files")
+        return True
 
-            logger.info(f"Saved config to {self._config_path}")
-            return True
+    def _save_to_monolithic(self, backup: bool) -> bool:
+        """
+        Save configuration to single monolithic file (legacy).
 
-        except (OSError, PermissionError) as e:
-            logger.error(f"Failed to save config: {e}")
-            return False
+        Args:
+            backup: If True, create backup before saving
+
+        Returns:
+            bool: True if successful
+        """
+        # Create backup if requested
+        if backup and self._config_path.exists():
+            self._create_backup()
+
+        # Atomic write pattern: temp file → rename
+        temp_path = self._config_path.with_suffix(".tmp")
+
+        # Write to temp file (auto-detect format)
+        with open(temp_path, "w", encoding="utf-8") as f:
+            if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
+                if not YAML_AVAILABLE:
+                    raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
+                yaml.safe_dump(
+                    self._config,
+                    f,
+                    default_flow_style=False,
+                    allow_unicode=True,
+                    sort_keys=False,
+                )
+            else:
+                json.dump(self._config, f, indent=2, ensure_ascii=False)
+
+        # Atomic rename
+        temp_path.replace(self._config_path)
+
+        # Update cache timestamp
+        self._last_modified = self._config_path.stat().st_mtime
+
+        logger.info(f"Saved config to {self._config_path}")
+        return True
 
     def _create_backup(self) -> None:
         """Create timestamped backup of config file."""
@@ -393,8 +548,34 @@ def get_unified_config(
 # Convenience functions for common operations
 @lru_cache(maxsize=1)
 def get_config_path() -> Path:
-    """Get path to configuration file."""
-    return Path.cwd() / ".moai" / "config" / "config.json"
+    """
+    Get path to configuration file or sections directory.
+
+    Returns:
+        Path: Path to sections directory (new) or config file (legacy)
+
+    Note: Prioritizes section-based config over monolithic files.
+          Legacy projects may still use config.json or config.yaml.
+    """
+    base_path = Path.cwd() / ".moai" / "config"
+    sections_dir = base_path / "sections"
+
+    # Priority 1: Section-based configuration (new approach)
+    if sections_dir.exists() and sections_dir.is_dir():
+        return sections_dir
+
+    # Priority 2: Monolithic YAML (legacy)
+    yaml_path = base_path / "config.yaml"
+    if yaml_path.exists():
+        return yaml_path
+
+    # Priority 3: Monolithic JSON (legacy)
+    json_path = base_path / "config.json"
+    if json_path.exists():
+        return json_path
+
+    # Default: Prefer sections for new projects
+    return sections_dir if YAML_AVAILABLE else yaml_path
 
 
 def get_config_value(key: str, default: Any = None) -> Any:

moai_adk/core/credentials.py

@@ -0,0 +1,264 @@
+"""Global credentials management for MoAI-ADK.
+
+Stores API keys:
+- GLM API key: ~/.moai/.env.glm (dotenv format)
+- Anthropic API key: ~/.moai/credentials.yaml (YAML format)
+"""
+
+import os
+import stat
+from pathlib import Path
+
+import yaml
+
+
+def get_credentials_path() -> Path:
+    """Get the global credentials file path.
+
+    Returns:
+        Path to ~/.moai/credentials.yaml
+    """
+    return Path.home() / ".moai" / "credentials.yaml"
+
+
+def get_env_glm_path() -> Path:
+    """Get the GLM API key file path.
+
+    Returns:
+        Path to ~/.moai/.env.glm
+    """
+    return Path.home() / ".moai" / ".env.glm"
+
+
+def glm_env_exists() -> bool:
+    """Check if GLM API key file exists.
+
+    Returns:
+        True if ~/.moai/.env.glm exists
+    """
+    return get_env_glm_path().exists()
+
+
+def load_glm_key_from_env() -> str | None:
+    """Load GLM API key from ~/.moai/.env.glm.
+
+    The file format is dotenv style: GLM_API_KEY=xxx
+
+    Returns:
+        GLM API key or None if not found
+    """
+    env_path = get_env_glm_path()
+
+    if not env_path.exists():
+        return None
+
+    try:
+        content = env_path.read_text().strip()
+        for line in content.splitlines():
+            line = line.strip()
+            if line.startswith("#") or not line:
+                continue
+            if line.startswith("GLM_API_KEY="):
+                # Remove quotes if present
+                value = line.split("=", 1)[1].strip()
+                if value.startswith('"') and value.endswith('"'):
+                    value = value[1:-1]
+                elif value.startswith("'") and value.endswith("'"):
+                    value = value[1:-1]
+                return value if value else None
+        return None
+    except OSError:
+        return None
+
+
+def save_glm_key_to_env(key: str) -> None:
+    """Save GLM API key to ~/.moai/.env.glm.
+
+    Args:
+        key: GLM API key to save
+    """
+    env_path = get_env_glm_path()
+
+    # Ensure directory exists
+    env_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write in dotenv format
+    content = f'# GLM API Key for MoAI-ADK\n# Generated by moai-adk\nGLM_API_KEY="{key}"\n'
+    env_path.write_text(content)
+
+    # Set file permissions to owner-only (chmod 600)
+    os.chmod(env_path, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def load_credentials() -> dict[str, str | None]:
+    """Load credentials from ~/.moai/credentials.yaml.
+
+    Returns:
+        Dict with api keys (values may be None if not set)
+    """
+    creds_path = get_credentials_path()
+
+    if not creds_path.exists():
+        return {"anthropic_api_key": None, "glm_api_key": None}
+
+    try:
+        data = yaml.safe_load(creds_path.read_text()) or {}
+        return {
+            "anthropic_api_key": data.get("anthropic_api_key"),
+            "glm_api_key": data.get("glm_api_key"),
+        }
+    except (yaml.YAMLError, OSError):
+        return {"anthropic_api_key": None, "glm_api_key": None}
+
+
+def save_credentials(
+    anthropic_api_key: str | None = None,
+    glm_api_key: str | None = None,
+    *,
+    merge: bool = True,
+) -> None:
+    """Save credentials to ~/.moai/credentials.yaml.
+
+    Args:
+        anthropic_api_key: Anthropic API key (None to skip)
+        glm_api_key: GLM API key (None to skip)
+        merge: If True, merge with existing credentials. If False, overwrite.
+    """
+    creds_path = get_credentials_path()
+
+    # Ensure directory exists
+    creds_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Load existing if merge mode
+    if merge:
+        existing = load_credentials()
+    else:
+        existing = {"anthropic_api_key": None, "glm_api_key": None}
+
+    # Build final data with new values taking precedence
+    data_to_save: dict[str, str] = {}
+
+    # Add anthropic key
+    final_anthropic = anthropic_api_key if anthropic_api_key is not None else existing.get("anthropic_api_key")
+    if final_anthropic:
+        data_to_save["anthropic_api_key"] = final_anthropic
+
+    # Add GLM key
+    final_glm = glm_api_key if glm_api_key is not None else existing.get("glm_api_key")
+    if final_glm:
+        data_to_save["glm_api_key"] = final_glm
+
+    # Write with secure permissions
+    creds_path.write_text(yaml.safe_dump(data_to_save, default_flow_style=False))
+
+    # Set file permissions to owner-only (chmod 600)
+    os.chmod(creds_path, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def get_glm_api_key() -> str | None:
+    """Get GLM API key from multiple sources.
+
+    Priority:
+    1. ~/.moai/.env.glm (explicit user config takes precedence)
+    2. ~/.moai/credentials.yaml (legacy, for backward compatibility)
+    3. Environment variable GLM_API_KEY (fallback for CI/CD or shell export)
+
+    Note: .env.glm file is prioritized over environment variable because
+    users explicitly save keys there via 'moai glm' command. Environment
+    variables may contain stale values from previous sessions.
+
+    Returns:
+        GLM API key or None if not found
+    """
+    # Check .env.glm file first (user's explicit choice)
+    env_glm_key = load_glm_key_from_env()
+    if env_glm_key:
+        return env_glm_key
+
+    # Fall back to credentials.yaml (legacy)
+    creds = load_credentials()
+    creds_key = creds.get("glm_api_key")
+    if creds_key:
+        return creds_key
+
+    # Finally check environment variable (for CI/CD or manual export)
+    env_key = os.environ.get("GLM_API_KEY")
+    if env_key:
+        return env_key
+
+    return None
+
+
+def get_anthropic_api_key() -> str | None:
+    """Get Anthropic API key from credentials or environment.
+
+    Priority:
+    1. Environment variable ANTHROPIC_API_KEY
+    2. ~/.moai/credentials.yaml
+
+    Returns:
+        Anthropic API key or None if not found
+    """
+    # Check environment first
+    env_key = os.environ.get("ANTHROPIC_API_KEY")
+    if env_key:
+        return env_key
+
+    # Fall back to credentials file
+    creds = load_credentials()
+    return creds.get("anthropic_api_key")
+
+
+def remove_glm_key_from_shell_config() -> dict[str, bool]:
+    """Remove GLM_API_KEY export from shell config files.
+
+    Removes lines matching 'export GLM_API_KEY=' from ~/.zshrc and ~/.bashrc.
+    Creates a backup before modifying.
+
+    Returns:
+        Dict with shell config names as keys and True if modified, False otherwise.
+        Example: {"zshrc": True, "bashrc": False}
+    """
+    import re
+    import shutil
+
+    results: dict[str, bool] = {}
+    shell_configs = [
+        (Path.home() / ".zshrc", "zshrc"),
+        (Path.home() / ".bashrc", "bashrc"),
+    ]
+
+    # Pattern to match: export GLM_API_KEY=... (with optional quotes)
+    pattern = re.compile(r"^\s*export\s+GLM_API_KEY\s*=.*$", re.MULTILINE)
+
+    for config_path, config_name in shell_configs:
+        if not config_path.exists():
+            results[config_name] = False
+            continue
+
+        try:
+            original_content = config_path.read_text()
+
+            # Check if pattern exists
+            if not pattern.search(original_content):
+                results[config_name] = False
+                continue
+
+            # Create backup before modifying
+            backup_path = config_path.with_suffix(f"{config_path.suffix}.moai-backup")
+            shutil.copy2(config_path, backup_path)
+
+            # Remove the export line(s)
+            new_content = pattern.sub("", original_content)
+
+            # Clean up multiple consecutive empty lines
+            new_content = re.sub(r"\n{3,}", "\n\n", new_content)
+
+            # Write back
+            config_path.write_text(new_content)
+            results[config_name] = True
+
+        except OSError:
+            results[config_name] = False
+
+    return results