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

moai_adk/core/context_manager.py

@@ -0,0 +1,273 @@
+"""
+Context Management Module for Commands Layer
+
+Provides utilities for:
+1. Path validation and absolute path conversion
+2. Atomic JSON file operations
+3. Phase result persistence and loading
+4. Template variable substitution
+"""
+
+import json
+import os
+import re
+import tempfile
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+# Constants
+PROJECT_ROOT_SAFETY_MSG = "Path outside project root: {}"
+PARENT_DIR_MISSING_MSG = "Parent directory not found: {}"
+
+
+def _is_path_within_root(abs_path: str, project_root: str) -> bool:
+    """
+    Check if absolute path is within project root.
+
+    Resolves symlinks to prevent escape attacks.
+
+    Args:
+        abs_path: Absolute path to check
+        project_root: Project root directory
+
+    Returns:
+        True if path is within root, False otherwise
+    """
+    try:
+        real_abs_path = os.path.realpath(abs_path)
+        real_project_root = os.path.realpath(project_root)
+
+        return real_abs_path == real_project_root or real_abs_path.startswith(real_project_root + os.sep)
+    except OSError:
+        return False
+
+
+def validate_and_convert_path(relative_path: str, project_root: str) -> str:
+    """
+    Convert relative path to absolute path and validate it.
+
+    Ensures path stays within project root and parent directories exist
+    for file paths.
+
+    Args:
+        relative_path: Path to validate and convert (relative or absolute)
+        project_root: Project root directory for relative path resolution
+
+    Returns:
+        Validated absolute path
+
+    Raises:
+        ValueError: If path is outside project root
+        FileNotFoundError: If parent directory doesn't exist for file paths
+    """
+    # Convert to absolute path
+    abs_path = os.path.abspath(os.path.join(project_root, relative_path))
+    project_root_abs = os.path.abspath(project_root)
+
+    # Security check: ensure path stays within project root
+    if not _is_path_within_root(abs_path, project_root_abs):
+        raise ValueError(PROJECT_ROOT_SAFETY_MSG.format(abs_path))
+
+    # If it's a directory and exists, return it
+    if os.path.isdir(abs_path):
+        return abs_path
+
+    # For files, check if parent directory exists
+    parent_dir = os.path.dirname(abs_path)
+    if not os.path.exists(parent_dir):
+        raise FileNotFoundError(PARENT_DIR_MISSING_MSG.format(parent_dir))
+
+    return abs_path
+
+
+def _cleanup_temp_file(temp_fd: Optional[int], temp_path: Optional[str]) -> None:
+    """
+    Clean up temporary file handles and paths.
+
+    Silently ignores errors during cleanup.
+
+    Args:
+        temp_fd: File descriptor to close, or None
+        temp_path: Path to file to remove, or None
+    """
+    if temp_fd is not None:
+        try:
+            os.close(temp_fd)
+        except OSError:
+            pass
+
+    if temp_path and os.path.exists(temp_path):
+        try:
+            os.unlink(temp_path)
+        except OSError:
+            pass
+
+
+def save_phase_result(data: Dict[str, Any], target_path: str) -> None:
+    """
+    Atomically save phase result to JSON file.
+
+    Uses temporary file and atomic rename to ensure data integrity
+    even if write fails midway.
+
+    Args:
+        data: Dictionary to save
+        target_path: Full path where JSON should be saved
+
+    Raises:
+        IOError: If write or rename fails
+        OSError: If directory is not writable
+    """
+    target_dir = os.path.dirname(target_path)
+    os.makedirs(target_dir, exist_ok=True)
+
+    # Atomic write using temp file
+    temp_fd = None
+    temp_path = None
+
+    try:
+        # Create temp file in target directory for atomic rename
+        temp_fd, temp_path = tempfile.mkstemp(dir=target_dir, prefix=".tmp_phase_", suffix=".json")
+
+        # Write JSON to temp file
+        with os.fdopen(temp_fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        temp_fd = None  # File handle is now closed
+
+        # Atomic rename
+        os.replace(temp_path, target_path)
+
+    except Exception as e:
+        _cleanup_temp_file(temp_fd, temp_path)
+        raise IOError(f"Failed to write {target_path}: {e}")
+
+
+def load_phase_result(source_path: str) -> Dict[str, Any]:
+    """
+    Load phase result from JSON file.
+
+    Args:
+        source_path: Full path to JSON file to load
+
+    Returns:
+        Dictionary containing phase result
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        json.JSONDecodeError: If file is not valid JSON
+    """
+    if not os.path.exists(source_path):
+        raise FileNotFoundError(f"Phase result file not found: {source_path}")
+
+    with open(source_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    return data
+
+
+def substitute_template_variables(text: str, context: Dict[str, str]) -> str:
+    """
+    Replace template variables in text with values from context.
+
+    Performs safe string substitution of {{VARIABLE}} placeholders.
+
+    Args:
+        text: Text containing {{VARIABLE}} placeholders
+        context: Dictionary mapping variable names to values
+
+    Returns:
+        Text with variables substituted
+    """
+    result = text
+
+    for key, value in context.items():
+        placeholder = f"{{{{{key}}}}}"
+        result = result.replace(placeholder, str(value))
+
+    return result
+
+
+# Regex pattern for detecting unsubstituted template variables
+# Matches {{VARIABLE}}, {{VAR_NAME}}, {{VAR1}}, etc.
+TEMPLATE_VAR_PATTERN = r"\{\{[A-Z_][A-Z0-9_]*\}\}"
+
+
+def validate_no_template_vars(text: str) -> None:
+    """
+    Validate that text contains no unsubstituted template variables.
+
+    Raises error if any {{VARIABLE}} patterns are found.
+
+    Args:
+        text: Text to validate
+
+    Raises:
+        ValueError: If unsubstituted variables are found
+    """
+    matches = re.findall(TEMPLATE_VAR_PATTERN, text)
+
+    if matches:
+        raise ValueError(f"Unsubstituted template variables found: {matches}")
+
+
+class ContextManager:
+    """
+    Manages context passing and state persistence for Commands layer.
+
+    Handles saving and loading phase results, managing state directory,
+    and providing convenient access to command state.
+    """
+
+    def __init__(self, project_root: str):
+        """
+        Initialize ContextManager.
+
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = project_root
+        self.state_dir = os.path.join(project_root, ".moai", "memory", "command-state")
+        os.makedirs(self.state_dir, exist_ok=True)
+
+    def save_phase_result(self, data: Dict[str, Any]) -> str:
+        """
+        Save phase result with timestamp.
+
+        Args:
+            data: Phase result data
+
+        Returns:
+            Path to saved file
+        """
+        # Generate filename with timestamp
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+        phase_name = data.get("phase", "unknown")
+        filename = f"{phase_name}-{timestamp}.json"
+        target_path = os.path.join(self.state_dir, filename)
+
+        save_phase_result(data, target_path)
+        return target_path
+
+    def load_latest_phase(self) -> Optional[Dict[str, Any]]:
+        """
+        Load the most recent phase result.
+
+        Returns:
+            Phase result dictionary or None if no phase files exist
+        """
+        # List all phase files
+        phase_files = sorted([f for f in os.listdir(self.state_dir) if f.endswith(".json")])
+
+        if not phase_files:
+            return None
+
+        # Load the latest (last in sorted order)
+        latest_file = phase_files[-1]
+        latest_path = os.path.join(self.state_dir, latest_file)
+
+        return load_phase_result(latest_path)
+
+    def get_state_dir(self) -> str:
+        """Get the command state directory path."""
+        return self.state_dir

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

moai_adk/core/diagnostics/slash_commands.py

@@ -1,4 +1,3 @@
-# @CODE:CLAUDE-COMMANDS-001:DIAGNOSTIC | SPEC: SPEC-CLAUDE-COMMANDS-001.md | TEST: tests/unit/test_slash_commands.py
 """Slash command diagnostics
 
 Diagnose and validate Claude Code slash command loading issues.