py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/config/core.py

@@ -0,0 +1,862 @@
+"""Configuration management utilities for WL Commands."""
+
+from __future__ import annotations
+
+import copy
+import json
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+from ..logging import log_error_pair
+from ..platform_adapter import PlatformAdapter
+from ..root import RootKind
+from ..root_fallback import resolve_root_or_start
+from .config_loader import ConfigLoader
+from .defaults import DEFAULT_LOG_FILE, RUNTIME_DERIVED_KEYS
+from .env_exporter import EnvExporter
+from .validation import validate_config
+
+# Directory and file paths
+CONFIG_FILE_NAME = "config.json"
+LOG_DIRECTORY = "log"
+LOG_FILE_NAME = "wl_action.log"
+
+# Environment variables
+WL_CONFIG_PATH_ENV = "WL_CONFIG_PATH"
+WL_ENVIRONMENT_ENV = "WL_ENVIRONMENT"
+
+# Environment names
+ENVIRONMENT_DEVELOPMENT = "development"
+ENVIRONMENT_PRODUCTION = "production"
+ENVIRONMENT_TESTING = "testing"
+
+# CI environment variables
+CI_ENV_VARS = ["CI", "GITHUB_ACTIONS", "JENKINS_HOME"]
+
+# Test environment variable
+TEST_ENV_VAR = "PYTEST_CURRENT_TEST"
+
+
+class ConfigPathResolver:
+    """Resolves configuration file paths with cross-platform support."""
+
+    def get_default_config_path(self) -> str:
+        """Get default configuration file path.
+
+        First checks environment variable WL_CONFIG_PATH_ENV, then resolves the
+        **deploy root** through the root module (the git work-tree root inside a
+        repository, else the project root -- see
+        :class:`~wl_cli.utils.root.RootKind`), falling back to the current
+        directory. Anchoring the config at the deploy root keeps it in the *same*
+        ``.wl`` as the hooks leg (#95 / #96); resolving it at the project root
+        split one ``.wl`` into two, so a workspace member repo silently stopped
+        reading the workspace config.
+
+        ``resolve`` answers ``None`` when there is neither a git work tree nor a
+        project marker; the substitution that used to hide inside the deploy
+        resolver (it returned the starting directory) is supplied by the single
+        CLI-top-level fallback policy,
+        :func:`~wl_cli.utils.root_fallback.resolve_root_or_start` (#126), per
+        ``docs/adr/0006-root-resolution-layering.md``.
+        """
+        config_path = os.environ.get(WL_CONFIG_PATH_ENV)
+        if config_path:
+            return config_path
+
+        try:
+            start = Path.cwd()
+        except OSError:
+            # A deleted working directory (#95): the chain this replaced
+            # (deploy resolver -> project walk) degraded to a relative ``.wl``
+            # rather than raising, so keep that result instead of letting
+            # ``Path.cwd()`` escape.
+            start = Path(".")
+
+        # ADR 0006: 回退是调用方策略；唯一实现在 utils/root_fallback.py（#126）.
+        # This is the one landing point that does NOT canonicalise ``start``: it
+        # passes the un-resolved ``Path.cwd()``, so the fallback answer keeps the
+        # spelling the old no-argument resolver returned.
+        deploy_root = resolve_root_or_start(start, RootKind.DEPLOY)
+
+        return str(deploy_root.wl_dir() / CONFIG_FILE_NAME)
+
+    def get_user_home_dir(self) -> str:
+        """Get user home directory in a cross-platform way.
+
+        Mirrors the platform order it has always had: ``Path.home()`` first, then
+        ``PATH``-independent ``~`` expansion with the Windows ``USERPROFILE`` /
+        ``HOMEDRIVE`` + ``HOMEPATH`` handling, and finally the caller-side
+        fallback to the current directory. That last step is a *fallback*, not
+        part of "which home does this platform have". ADR 0006 keeps it written
+        out here rather than inside a resolver, and #126 deliberately does **not**
+        fold it into the single root-fallback policy: the question here is the
+        user's **home**, a different domain from the project **root**, so merging
+        the two would conflate them (see ADR 0006 修订 1).
+        """
+        try:
+            return str(Path.home())
+        except Exception:
+            # Fallback for when Path.home() fails
+            home_dir = os.path.expanduser("~")
+
+            # Windows-specific additional handling
+            if PlatformAdapter.is_windows() and (not home_dir or home_dir == "~"):
+                home_dir = os.environ.get("USERPROFILE", "")
+                if not home_dir:
+                    home_drive = os.environ.get("HOMEDRIVE", "")
+                    home_path_env = os.environ.get("HOMEPATH", "")
+                    if home_drive and home_path_env:
+                        home_dir = os.path.join(home_drive, home_path_env)
+
+            # Final fallback
+            if not home_dir or home_dir == "~":
+                # ADR 0006: 这是 home 解析兜底（C 类），非「根回退」，按
+                # ADR 修订 1 的裁决保留、不收编（#126）。
+                home_dir = os.getcwd()
+
+            return home_dir
+
+
+class ConfigMerger:
+    """Recursively merge configuration dictionaries with proper precedence."""
+
+    def merge(self, base: dict[str, Any], *overlays: dict[str, Any]) -> dict[str, Any]:
+        """Recursively merge multiple configuration dictionaries.
+
+        Later overlays override earlier ones. For nested dictionaries,
+        merging is done recursively rather than replacing the whole dict.
+
+        Args:
+            base: Base configuration
+            *overlays: Overlay configurations to merge on top
+
+        Returns:
+            New merged configuration dictionary (base is not modified)
+        """
+        result = copy.deepcopy(base)
+        for overlay in overlays:
+            self._recursive_merge(result, overlay)
+        return result
+
+    def _recursive_merge(self, target: dict[str, Any], source: dict[str, Any]) -> None:
+        """Recursively merge source into target."""
+        for key, value in source.items():
+            if (
+                key in target
+                and isinstance(target[key], dict)
+                and isinstance(value, dict)
+            ):
+                self._recursive_merge(target[key], value)
+            else:
+                target[key] = value
+
+    def merge_changed_keys(
+        self,
+        target: dict[str, Any],
+        source: dict[str, Any],
+        original: dict[str, Any],
+    ) -> None:
+        """Merge only changed keys from source into target.
+
+        Only adds/updates keys that are not in original or have changed value.
+        Used for saving configuration to preserve original user settings.
+
+        Args:
+            target: Target dictionary to update
+            source: Source dictionary with current values
+            original: Original dictionary to compare against
+        """
+        for key, value in source.items():
+            if key not in original:
+                # Key doesn't exist in original, add it
+                target[key] = value
+            elif isinstance(value, dict) and isinstance(original[key], dict):
+                # Both are dicts, recursively check nested keys
+                if key not in target:
+                    target[key] = {}
+                self.merge_changed_keys(target[key], value, original[key])
+            elif value != original.get(key):
+                # Value has changed, update it
+                target[key] = value
+
+
+class ConfigSaver:
+    """Save configuration to file with smart change tracking.
+
+    Only saves changed keys compared to the original project configuration,
+    preserving default values that aren't saved to disk.
+    """
+
+    def __init__(self, config_file_path: str) -> None:
+        """Initialize configuration saver.
+
+        Args:
+            config_file_path: Path to the configuration file to save
+        """
+        self.config_file_path = config_file_path
+        self.merger = ConfigMerger()
+
+    def save(
+        self,
+        full_config: dict[str, Any],
+        original_project_config: dict[str, Any],
+        *,
+        force: bool = False,
+    ) -> bool:
+        """Save configuration changes to file.
+
+        Only saves keys that have changed from the original project config.
+        Creates parent directory if it doesn't exist.
+
+        Args:
+            full_config: Complete merged configuration from all sources
+            original_project_config: Original project configuration as loaded from disk
+            force: Write even in a test environment. The test-environment skip
+                below is a default for *incidental* saves; an explicit
+                "materialise this file" call must not inherit it, or the caller
+                gets ``True`` for a file that was never written (#202).
+
+        Returns:
+            True when the file was written (or the write was intentionally
+            skipped in a test environment without ``force``); False when the
+            write failed. The error is logged -- callers such as ``wl config
+            set`` and the .wl self-sync must be able to report the failure
+            instead of claiming success (#177).
+        """
+        # Don't save to disk in test environment -- unless the caller is
+        # explicitly materialising a file (see ``force``).
+        if not force and os.environ.get(TEST_ENV_VAR):
+            return True
+
+        try:
+            config_path = Path(self.config_file_path)
+            config_dir = config_path.parent
+            if config_dir and not config_dir.exists():
+                config_dir.mkdir(parents=True, exist_ok=True)
+
+            # Only save the original project config plus any new keys that were set
+            # This prevents default values from being saved to the config file
+            if original_project_config:
+                # Use deep copy to ensure no mutation of original input
+                config_to_save = copy.deepcopy(original_project_config)
+                self.merger.merge_changed_keys(
+                    config_to_save, full_config, original_project_config
+                )
+            else:
+                # If no original project config, just save a deep copy of current config
+                config_to_save = copy.deepcopy(full_config)
+
+            with open(self.config_file_path, "w", encoding="utf-8") as f:
+                json.dump(config_to_save, f, indent=2, ensure_ascii=False)
+                f.write("\n")
+            return True
+        except OSError as e:
+            # Saving is still best-effort, but no longer silent: the caller gets
+            # False and the user gets a bilingual error (#177).
+            log_error_pair(
+                f"Failed to save configuration to {self.config_file_path}: {e}",
+                f"无法将配置保存到 {self.config_file_path}：{e}",
+            )
+            return False
+
+
+class ConfigManager:
+    """Manage application configuration with auto-reload support.
+
+    This is a facade that delegates to smaller, single-responsibility components:
+    - ConfigPathResolver: Resolves configuration file paths
+    - ConfigLoader: Loads configuration from multiple sources
+    - ConfigSaver: Saves configuration changes smartly
+    """
+
+    def __init__(self, config_file: str | None = None) -> None:
+        """
+        Initialize configuration manager with support for configuration layers.
+
+        Args:
+            config_file (str, optional): Path to project configuration file.
+        """
+        self._path_resolver = ConfigPathResolver()
+        self.config_file = config_file or self._path_resolver.get_default_config_path()
+        self._loader = ConfigLoader(self.config_file, self._path_resolver)
+        self._env_exporter = EnvExporter(self._loader)
+        self._config: dict[str, Any] = {}
+        self._last_modified_time: float = 0.0
+        self._original_project_config: dict[str, Any] = {}
+        # Top-level keys this process set explicitly. A runtime-derived key is
+        # only written to disk when it is in here (#208).
+        self._explicit_keys: set[str] = set()
+        self._load_config()
+
+    def _get_default_config(self) -> dict[str, Any]:
+        """Get default configuration dictionary.
+
+        This is kept for backward compatibility with tests.
+        """
+        from .defaults import get_default_config
+
+        return get_default_config()
+
+    def _get_environment(self) -> str:
+        """Get current environment mode.
+
+        This is kept for backward compatibility with tests.
+        """
+        return self._loader.get_environment()
+
+    def _load_config(self) -> None:
+        """Load configuration from all sources using ConfigLoader."""
+        # Load all configuration layers
+        merged_config = self._loader.load_all()
+
+        # Save original project config for later comparison when saving
+        project_config = self._loader.load_config_file(self.config_file)
+        self._original_project_config = project_config.copy()
+
+        # Validate configuration
+        self._config = validate_config(merged_config)
+
+        # Loading is a **read** and must never materialise the project config.
+        # Writing here meant that merely importing wl_cli (module-level logger →
+        # LoggingConfig → get_config) dropped a `.wl/` into whatever directory
+        # happened to be the CWD — see the lazy logger in utils/logging.py.
+        #
+        # Creating the file is an explicit act now: `wl init` calls
+        # ensure_project_config(), and `set()` still persists on a write.
+        #
+        # Gating the write on "does the project dir exist?" was tried and is NOT
+        # enough: get_config_manager() is a process-cached singleton, so the
+        # decision falls to whichever call happens to run first — and `wl init`
+        # logs before it ever reaches generate_configs(), so the manager gets
+        # built while `.wl/` does not exist yet and never re-checks.
+        self._last_modified_time = time.time()
+
+    def ensure_project_config(self) -> bool:
+        """Materialise the project config file, writing defaults when absent.
+
+        The one explicit way to create `.wl/config.json`. `wl init` calls this;
+        nothing else should need to, because every other path either only reads
+        or writes through `set()`.
+
+        This is a *create* contract, so it passes ``force`` down: under pytest
+        the incidental-save guard would otherwise answer "written" while leaving
+        no file behind, and the .wl self-sync then half-materialised a checkout
+        -- templates deployed, no `config.json`, a failed version stamp and the
+        one-hour `.update_failed` cooldown on a brand-new worktree (#202).
+
+        It also writes the *creation* defaults rather than ``self._config``.
+        ``self._config`` is the merged runtime view, so it carries values derived
+        from the process that happens to be creating the file -- under pytest
+        ``environment=testing``, in CI ``production``. Since ``load_all`` prefers
+        the file's ``environment`` over detection, persisting that value turned
+        a derivation into a permanent override, and the version stamp then
+        certified it as current (#208). See
+        :func:`~wl_cli.utils.config.defaults.get_creation_defaults`.
+
+        Returns:
+            True when the file exists afterwards; False when the defaults could
+            not be written (#202).
+        """
+        if os.path.exists(self.config_file):
+            return True
+        ok = self._save_config(force=True, creation=True)
+        return ok and os.path.exists(self.config_file)
+
+    def _persistable_config(self) -> dict[str, Any]:
+        """The merged config minus runtime-derived values nobody set (#208).
+
+        ``self._config`` is the merged runtime view, and ``ConfigLoader.load_all``
+        always fills in ``environment`` -- derived from this process or read back
+        from the file. Writing that value on an ordinary save would recreate the
+        permanent override that :meth:`ensure_project_config` deliberately keeps
+        out of a new file, so it reaches disk only when ``set()`` recorded it as
+        explicit user intent.
+
+        Returns:
+            A shallow copy of the merged config safe to persist.
+        """
+        return {
+            key: value
+            for key, value in self._config.items()
+            if key not in RUNTIME_DERIVED_KEYS or key in self._explicit_keys
+        }
+
+    def _save_config(self, *, force: bool = False, creation: bool = False) -> bool:
+        """Save configuration to file using ConfigSaver.
+
+        Args:
+            force: Write even in a test environment (see
+                :meth:`ensure_project_config`).
+            creation: Write the environment-independent creation payload instead
+                of the merged runtime config (see :meth:`ensure_project_config`).
+                Only the create path passes this; ``set()`` keeps persisting the
+                merged config, so an explicit ``wl config set environment ...``
+                is still written as the user's own setting (#208).
+
+        The runtime-derived keys are filtered out of the merged view unless
+        ``set()`` recorded them as explicit user intent. Doing this only on the
+        create path would leave the invariant one ``wl config set`` away from
+        being undone: the merged view always carries ``environment``, so the
+        first ordinary save in an empty repo (or any save in CI) wrote the
+        derivation back into the neutral file (#208).
+
+        Returns:
+            True when the write succeeded; False when it failed (#177).
+        """
+        if creation:
+            from .defaults import get_creation_defaults
+
+            full_config, original_config = get_creation_defaults(), {}
+        else:
+            full_config = self._persistable_config()
+            original_config = self._original_project_config
+
+        saver = ConfigSaver(self.config_file)
+        ok = saver.save(
+            full_config=full_config,
+            original_project_config=original_config,
+            force=force,
+        )
+        if ok:
+            # Only a real (or intentionally skipped) save resets the reload
+            # baseline; a failed write leaves the on-disk state behind.
+            self._last_modified_time = time.time()
+        return ok
+
+    def _should_reload(self) -> bool:
+        """Check if configuration should be reloaded based on file modification time."""
+        # In test environment, never reload configuration to prevent losing test data
+        if os.environ.get(TEST_ENV_VAR):
+            return False
+        try:
+            config_path = Path(self.config_file)
+            if config_path.exists():
+                current_mtime = config_path.stat().st_mtime
+                return current_mtime > self._last_modified_time
+        except OSError:
+            pass
+        return False
+
+    def get(self, key: str, default: Any = None, auto_reload: bool = True) -> Any:
+        """
+        Get configuration value with support for nested keys.
+
+        Args:
+            key (str): Configuration key (supports dot notation for nested keys).
+            default (Any, optional): Default value if key not found.
+            auto_reload (bool, optional): Whether to automatically reload if config file changed.
+
+        Returns:
+            Any: Configuration value.
+        """
+        if auto_reload and self._should_reload():
+            self._load_config()
+
+        # Support dot notation for nested keys
+        value = self._config
+        for part in key.split("."):
+            if isinstance(value, dict) and part in value:
+                value = value[part]
+            else:
+                return default
+
+        if key == "log_file" and value and isinstance(value, str):
+            log_path = Path(value)
+            if log_path.is_absolute():
+                return value
+            # Check if value is the default log file path pattern
+            default_log_path = Path(DEFAULT_LOG_FILE)
+            if log_path == default_log_path:
+                return value
+            config_dir = Path(self.config_file).parent
+            return str(config_dir / value)
+
+        return value
+
+    def set(self, key: str, value: Any) -> bool:
+        """Set configuration value with support for nested keys.
+
+        Returns:
+            True when the change was persisted (or the write was intentionally
+            skipped in a test environment); False when the write failed (#177).
+        """
+        # Support dot notation for nested keys
+        parts = key.split(".")
+        config = self._config
+
+        for part in parts[:-1]:
+            if part not in config or not isinstance(config[part], dict):
+                config[part] = {}
+            config = config[part]
+
+        config[parts[-1]] = value
+        # A runtime-derived key only becomes writable when the user names it:
+        # an explicit ``wl config set environment ...`` is intent, a derivation
+        # is not (#208).
+        self._explicit_keys.add(parts[0])
+        # Only save if not in test environment
+        if not os.environ.get(TEST_ENV_VAR):
+            return self._save_config()
+        # In test environment, update last modified time to prevent unnecessary reload
+        self._last_modified_time = time.time()
+        return True
+
+    def unset(self, key: str) -> bool:
+        """Remove a top-level ``key`` from the project config file.
+
+        ``wl config reset`` uses this for runtime-derived keys: their default is
+        a *derivation* (``development``), not a project setting, so writing it
+        back would freeze exactly the value #208 keeps out of the file. Deleting
+        the key restores derivation on the next load, and also clears the
+        in-memory merged value so a later get does not read the stale one.
+
+        Returns:
+            True when the removal was persisted (or the write was intentionally
+            skipped in a test environment); False when the write failed (#177).
+        """
+        self._explicit_keys.discard(key)
+        self._config.pop(key, None)
+        self._original_project_config.pop(key, None)
+        if key in RUNTIME_DERIVED_KEYS:
+            # Keep the merged view complete for the rest of the process: readers
+            # still need a value, and the re-derived one is filtered back out of
+            # any later write (see ``_persistable_config``).
+            self._config[key] = self._loader.get_environment()
+        if not os.environ.get(TEST_ENV_VAR):
+            return self._save_config()
+        self._last_modified_time = time.time()
+        return True
+
+    def get_all(self, auto_reload: bool = True) -> dict[str, Any]:
+        """Get all configuration."""
+        if auto_reload and self._should_reload():
+            self._load_config()
+        return self._config.copy()
+
+    def reload(self) -> None:
+        """Reload configuration from all sources."""
+        self._load_config()
+
+    def hot_reload(self) -> bool:
+        """
+        Hot reload configuration from file.
+
+        Returns:
+            bool: True if configuration was reloaded, False otherwise.
+        """
+        # Save current config
+        current_config = self._config.copy()
+
+        # In test environment, always reload to ensure test data is loaded
+        if os.environ.get(TEST_ENV_VAR):
+            self._load_config()
+            # Restore current config in test environment
+            for key, value in current_config.items():
+                self._config[key] = value
+            return True
+        if self._should_reload():
+            self._load_config()
+            # Restore existing keys that weren't reloaded to maintain current state
+            for key, value in current_config.items():
+                if key not in self._config:
+                    self._config[key] = value
+            return True
+        return False
+
+    def export_environment_variables(
+        self, environment: str | None = None
+    ) -> dict[str, str]:
+        """Export current configuration as environment variables."""
+        config = self.get_all()
+        return self._env_exporter.export_environment_variables(config, environment)
+
+    def get_environment_template(self, environment: str) -> dict[str, str]:
+        """Get environment variable template for specific environment."""
+        return self._env_exporter.get_environment_template(environment)
+
+
+_config_manager: ConfigManager | None = None
+_config_manager_lock = threading.RLock()
+
+
+class ConfigContext:
+    """配置上下文管理器，用于管理配置的作用域"""
+
+    def __init__(self, config_manager: ConfigManager | None = None) -> None:
+        """初始化配置上下文
+
+        Args:
+            config_manager: 自定义配置管理器实例，如果为None则使用全局实例
+        """
+        self._custom_manager = config_manager or ConfigManager()
+        self._original_manager: ConfigManager | None = None
+
+    def __enter__(self) -> ConfigManager:
+        """进入上下文，返回配置管理器"""
+        # 保存原始管理器
+        global _config_manager
+        with _config_manager_lock:
+            self._original_manager = _config_manager
+            _config_manager = self._custom_manager
+        return self._custom_manager
+
+    def __exit__(self, *_) -> None:
+        """退出上下文，恢复原始管理器"""
+        global _config_manager
+        with _config_manager_lock:
+            # 强制恢复原始管理器，即使它是None
+            _config_manager = self._original_manager
+
+
+class ConfigProvider:
+    """配置提供者，用于依赖注入
+
+    ConfigProvider provides a way to inject configuration management into other components
+    without relying on global state. It can either use a custom ConfigManager instance
+    or fall back to the global one.
+    """
+
+    def __init__(self, config_manager: ConfigManager | None = None):
+        """初始化配置提供者
+
+        Args:
+            config_manager: 配置管理器实例，如果为None则使用全局实例
+        """
+        self._config_manager = config_manager
+
+    def get_config(self, key: str, default: Any = None) -> Any:
+        """获取配置值
+
+        Args:
+            key: 配置键（支持点号表示嵌套键）
+            default: 默认值，如果键不存在则返回
+
+        Returns:
+            配置值
+        """
+        from .core import get_config_manager
+
+        manager = self._config_manager or get_config_manager()
+        return manager.get(key, default)
+
+    def set_config(self, key: str, value: Any) -> None:
+        """设置配置值
+
+        Args:
+            key: 配置键（支持点号表示嵌套键）
+            value: 配置值
+        """
+        from .core import get_config_manager
+
+        manager = self._config_manager or get_config_manager()
+        manager.set(key, value)
+
+    def get_all(self) -> dict[str, Any]:
+        """获取所有配置
+
+        Returns:
+            所有配置的字典副本
+        """
+        from .core import get_config_manager
+
+        manager = self._config_manager or get_config_manager()
+        return manager.get_all()
+
+    def reload(self) -> None:
+        """重新加载配置
+
+        Reloads configuration from all sources (file, environment variables, etc.)
+        """
+        from .core import get_config_manager
+
+        manager = self._config_manager or get_config_manager()
+        manager.reload()
+
+    @property
+    def config_manager(self) -> ConfigManager:
+        """获取配置管理器实例
+
+        Returns:
+            配置管理器实例
+        """
+        from .core import get_config_manager
+
+        return self._config_manager or get_config_manager()
+
+
+def get_config_manager() -> ConfigManager:
+    """Get global configuration manager instance.
+
+    Returns:
+        Global ConfigManager instance
+    """
+    import os
+    import tempfile
+
+    global _config_manager
+    with _config_manager_lock:
+        if _config_manager is None:
+            # In test environment, create a ConfigManager with an empty configuration
+            if os.environ.get(TEST_ENV_VAR):
+                with tempfile.NamedTemporaryFile(
+                    mode="w", suffix=".json", delete=False
+                ) as f:
+                    f.write("{}")  # 写入空配置
+                    temp_config_file = f.name
+                try:
+                    _config_manager = ConfigManager(config_file=temp_config_file)
+                finally:
+                    if os.path.exists(temp_config_file):
+                        os.unlink(temp_config_file)
+            else:
+                _config_manager = ConfigManager()
+        return _config_manager
+
+
+def get_config(key: str, default: Any = None) -> Any:
+    """Get configuration value from global manager with auto-reload.
+
+    Args:
+        key: 配置键（支持点号表示嵌套键）
+        default: 默认值，如果键不存在则返回
+
+    Returns:
+        配置值
+    """
+    return get_config_manager().get(key, default)
+
+
+def set_config(key: str, value: Any) -> None:
+    """Set configuration value using the global manager.
+
+    Args:
+        key: 配置键（支持点号表示嵌套键）
+        value: 配置值
+    """
+    get_config_manager().set(key, value)
+
+
+def reload_config() -> bool:
+    """Reload global configuration.
+
+    Returns:
+        True if configuration was reloaded, False otherwise
+    """
+    return get_config_manager().hot_reload()
+
+
+def reset_config_manager() -> None:
+    """重置全局配置管理器，主要用于测试
+
+    Resets the global configuration manager instance to None, forcing a new instance
+    to be created on the next call to get_config_manager().
+    """
+    global _config_manager
+    with _config_manager_lock:
+        _config_manager = None
+
+
+# Multi-language message mappings
+MESSAGES = {
+    "en": {
+        "config": {
+            "loaded": "Configuration loaded successfully",
+            "reloaded": "Configuration reloaded successfully",
+            "saved": "Configuration saved successfully",
+            "not_found": "Configuration file not found, using defaults",
+            "invalid": "Invalid configuration, using defaults",
+        },
+        "errors": {
+            "file_not_found": "File not found: {path}",
+            "permission_denied": "Permission denied: {path}",
+            "invalid_input": "Invalid input: {message}",
+            "command_failed": "Command failed: {command}",
+            "unknown_error": "Unknown error occurred",
+        },
+        "info": {
+            "starting": "Starting {command}",
+            "completed": "{command} completed successfully",
+            "skipped": "{command} skipped",
+            "warning": "Warning: {message}",
+        },
+    },
+    "zh": {
+        "config": {
+            "loaded": "配置加载成功",
+            "reloaded": "配置重新加载成功",
+            "saved": "配置保存成功",
+            "not_found": "未找到配置文件，使用默认值",
+            "invalid": "无效的配置，使用默认值",
+        },
+        "errors": {
+            "file_not_found": "文件未找到: {path}",
+            "permission_denied": "权限被拒绝: {path}",
+            "invalid_input": "无效的输入: {message}",
+            "command_failed": "命令执行失败: {command}",
+            "unknown_error": "发生未知错误",
+        },
+        "info": {
+            "starting": "正在启动 {command}",
+            "completed": "{command} 执行成功",
+            "skipped": "{command} 已跳过",
+            "warning": "警告: {message}",
+        },
+    },
+}
+
+
+def get_message(key: str, language: str = "auto", **kwargs) -> str:
+    """
+    Get message in specified language.
+
+    Args:
+        key: Message key in format "category.message"
+        language: Language code ("en", "zh", or "auto")
+        **kwargs: Parameters to format the message
+
+    Returns:
+        Formatted message string
+    """
+    from ..language_utils import _should_display_language
+
+    # Determine language if auto
+    if language == "auto":
+        if _should_display_language("zh"):
+            language = "zh"
+        else:
+            language = "en"
+
+    # Default to English if language not supported
+    if language not in MESSAGES:
+        language = "en"
+
+    # Split key into category and message
+    parts = key.split(".")
+    if len(parts) != 2:
+        return f"Message not found: {key}"
+
+    category, message_key = parts
+
+    # Get message from dictionary
+    try:
+        message = MESSAGES[language][category][message_key]
+        return message.format(**kwargs)
+    except KeyError:
+        return f"Message not found: {key}"
+
+
+__all__ = [
+    "ConfigManager",
+    "ConfigContext",
+    "ConfigProvider",
+    "EnvExporter",
+    "get_config_manager",
+    "get_config",
+    "set_config",
+    "reload_config",
+    "reset_config_manager",
+    "get_message",
+]