praisonai-code 0.0.1__py3-none-any.whl

praisonai_code/cli/configuration/loader.py

@@ -0,0 +1,364 @@
+"""
+Configuration loader for PraisonAI CLI.
+
+Handles loading, merging, and saving configuration with precedence.
+"""
+
+import os
+import threading
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from .paths import (
+    get_config_paths,
+    get_user_config_path,
+    get_project_config_path,
+    get_env_prefix,
+    ensure_config_dirs,
+    find_project_root,
+)
+from .schema import ConfigSchema, DEFAULT_CONFIG
+
+
+# Thread-safe config cache
+_config_lock = threading.Lock()
+_config_cache: Optional[ConfigSchema] = None
+
+
+def _load_toml(path: Path) -> Dict[str, Any]:
+    """Load a TOML file."""
+    try:
+        # Try tomllib (Python 3.11+) first
+        import tomllib
+        with open(path, "rb") as f:
+            return tomllib.load(f)
+    except ImportError:
+        pass
+    
+    try:
+        # Fall back to tomli
+        import tomli
+        with open(path, "rb") as f:
+            return tomli.load(f)
+    except ImportError:
+        pass
+    
+    # Last resort: basic TOML parsing
+    return _basic_toml_parse(path)
+
+
+def _basic_toml_parse(path: Path) -> Dict[str, Any]:
+    """Basic TOML parser for simple configs."""
+    result: Dict[str, Any] = {}
+    current_section: Optional[str] = None
+    
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            
+            if line.startswith("[") and line.endswith("]"):
+                current_section = line[1:-1]
+                if current_section not in result:
+                    result[current_section] = {}
+            elif "=" in line:
+                key, value = line.split("=", 1)
+                key = key.strip()
+                value = value.strip()
+                
+                # Parse value
+                if value.lower() == "true":
+                    parsed_value = True
+                elif value.lower() == "false":
+                    parsed_value = False
+                elif value.startswith('"') and value.endswith('"'):
+                    parsed_value = value[1:-1]
+                elif value.startswith("'") and value.endswith("'"):
+                    parsed_value = value[1:-1]
+                else:
+                    try:
+                        parsed_value = int(value)
+                    except ValueError:
+                        try:
+                            parsed_value = float(value)
+                        except ValueError:
+                            parsed_value = value
+                
+                if current_section:
+                    result[current_section][key] = parsed_value
+                else:
+                    result[key] = parsed_value
+    
+    return result
+
+
+def _save_toml(path: Path, data: Dict[str, Any]) -> None:
+    """Save data to a TOML file."""
+    try:
+        import tomli_w
+        with open(path, "wb") as f:
+            tomli_w.dump(data, f)
+        return
+    except ImportError:
+        pass
+    
+    # Fall back to basic TOML writing
+    _basic_toml_write(path, data)
+
+
+def _basic_toml_write(path: Path, data: Dict[str, Any]) -> None:
+    """Basic TOML writer."""
+    lines = []
+    
+    # Write top-level keys first
+    for key, value in data.items():
+        if not isinstance(value, dict):
+            lines.append(f"{key} = {_format_toml_value(value)}")
+    
+    # Write sections
+    for key, value in data.items():
+        if isinstance(value, dict):
+            lines.append(f"\n[{key}]")
+            for sub_key, sub_value in value.items():
+                if not isinstance(sub_value, dict):
+                    lines.append(f"{sub_key} = {_format_toml_value(sub_value)}")
+                else:
+                    # Nested section
+                    lines.append(f"\n[{key}.{sub_key}]")
+                    for nested_key, nested_value in sub_value.items():
+                        lines.append(f"{nested_key} = {_format_toml_value(nested_value)}")
+    
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines) + "\n")
+
+
+def _format_toml_value(value: Any) -> str:
+    """Format a value for TOML."""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    elif isinstance(value, str):
+        return f'"{value}"'
+    elif isinstance(value, (int, float)):
+        return str(value)
+    elif isinstance(value, list):
+        items = ", ".join(_format_toml_value(v) for v in value)
+        return f"[{items}]"
+    else:
+        return f'"{value}"'
+
+
+def _merge_dicts(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    """Deep merge two dictionaries."""
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _merge_dicts(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _get_env_overrides() -> Dict[str, Any]:
+    """Get configuration overrides from environment variables."""
+    prefix = get_env_prefix()
+    overrides: Dict[str, Any] = {}
+    
+    for key, value in os.environ.items():
+        if not key.startswith(prefix):
+            continue
+        
+        # Convert PRAISONAI_OUTPUT_FORMAT to output.format
+        config_key = key[len(prefix):].lower()
+        parts = config_key.split("_")
+        
+        # Parse value
+        if value.lower() == "true":
+            parsed_value = True
+        elif value.lower() == "false":
+            parsed_value = False
+        else:
+            try:
+                parsed_value = int(value)
+            except ValueError:
+                try:
+                    parsed_value = float(value)
+                except ValueError:
+                    parsed_value = value
+        
+        # Build nested dict
+        if len(parts) >= 2:
+            section = parts[0]
+            sub_key = "_".join(parts[1:])
+            if section not in overrides:
+                overrides[section] = {}
+            overrides[section][sub_key] = parsed_value
+        else:
+            overrides[config_key] = parsed_value
+    
+    return overrides
+
+
+def _get_dotted_value(data: Dict[str, Any], key: str) -> Any:
+    """Get a value using dotted key notation."""
+    parts = key.split(".")
+    current = data
+    for part in parts:
+        if isinstance(current, dict) and part in current:
+            current = current[part]
+        else:
+            return None
+    return current
+
+
+def _set_dotted_value(data: Dict[str, Any], key: str, value: Any) -> None:
+    """Set a value using dotted key notation."""
+    parts = key.split(".")
+    current = data
+    for part in parts[:-1]:
+        if part not in current:
+            current[part] = {}
+        current = current[part]
+    current[parts[-1]] = value
+
+
+class ConfigLoader:
+    """
+    Configuration loader with precedence handling.
+    
+    Precedence (highest to lowest):
+    1. CLI flags (not handled here)
+    2. Environment variables (PRAISONAI_*)
+    3. Project config (.praison/config.toml)
+    4. User config (~/.praison/config.toml)
+    5. Defaults
+    """
+    
+    def __init__(self, project_root: Optional[Path] = None):
+        # Remember whether the caller pinned an explicit root. When they did,
+        # config resolution stays anchored to that single root; otherwise we
+        # let get_config_paths() walk the cwd→project-root ancestor chain so
+        # nested .praison/config.toml files are merged (nearest wins).
+        self._explicit_root = project_root
+        self.project_root = project_root or find_project_root() or Path.cwd()
+        self._config: Optional[ConfigSchema] = None
+        self._raw_config: Dict[str, Any] = {}
+    
+    def load(self, force_reload: bool = False) -> ConfigSchema:
+        """Load configuration with precedence."""
+        if self._config is not None and not force_reload:
+            return self._config
+        
+        # Start with defaults
+        merged = DEFAULT_CONFIG.to_dict()
+        
+        # Load config files in reverse precedence order
+        config_paths = get_config_paths(self._explicit_root)
+        for path in reversed(config_paths):
+            try:
+                file_config = _load_toml(path)
+                merged = _merge_dicts(merged, file_config)
+            except Exception:
+                pass  # Skip invalid files
+        
+        # Apply environment overrides
+        env_overrides = _get_env_overrides()
+        merged = _merge_dicts(merged, env_overrides)
+        
+        self._raw_config = merged
+        self._config = ConfigSchema.from_dict(merged)
+        return self._config
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a configuration value using dotted key notation."""
+        self.load()
+        value = _get_dotted_value(self._raw_config, key)
+        return value if value is not None else default
+    
+    def set(self, key: str, value: Any, scope: str = "user") -> None:
+        """
+        Set a configuration value.
+        
+        Args:
+            key: Dotted key notation (e.g., "output.format")
+            value: Value to set
+            scope: "user" or "project"
+        """
+        if scope == "project":
+            config_path = get_project_config_path(self.project_root)
+        else:
+            config_path = get_user_config_path()
+        
+        # Load existing config or create empty
+        if config_path.exists():
+            try:
+                existing = _load_toml(config_path)
+            except Exception:
+                existing = {}
+        else:
+            existing = {}
+        
+        # Set the value
+        _set_dotted_value(existing, key, value)
+        
+        # Ensure directory exists
+        ensure_config_dirs()
+        if scope == "project":
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Save
+        _save_toml(config_path, existing)
+        
+        # Reload
+        self.load(force_reload=True)
+    
+    def reset(self, scope: str = "user") -> None:
+        """Reset configuration to defaults."""
+        if scope == "project":
+            config_path = get_project_config_path(self.project_root)
+        else:
+            config_path = get_user_config_path()
+        
+        if config_path.exists():
+            config_path.unlink()
+        
+        self.load(force_reload=True)
+    
+    def list_all(self) -> Dict[str, Any]:
+        """List all configuration values."""
+        self.load()
+        return self._raw_config.copy()
+
+
+# Global config loader
+_global_loader: Optional[ConfigLoader] = None
+
+
+def get_config(project_root: Optional[Path] = None) -> ConfigSchema:
+    """Get the global configuration."""
+    global _global_loader, _config_cache
+    
+    with _config_lock:
+        if _global_loader is None or project_root is not None:
+            _global_loader = ConfigLoader(project_root)
+        
+        if _config_cache is None:
+            _config_cache = _global_loader.load()
+        
+        return _config_cache
+
+
+def load_config(project_root: Optional[Path] = None) -> ConfigSchema:
+    """Alias for get_config(); loads the global configuration."""
+    return get_config(project_root)
+
+
+def get_config_loader(project_root: Optional[Path] = None) -> ConfigLoader:
+    """Get the global config loader."""
+    global _global_loader
+    
+    with _config_lock:
+        if _global_loader is None or project_root is not None:
+            _global_loader = ConfigLoader(project_root)
+        return _global_loader

praisonai_code/cli/configuration/model_resolver.py

@@ -0,0 +1,161 @@
+"""
+Provider-aware default model resolution with last-used recency.
+
+Resolves a sensible default model for zero-config first runs in this
+precedence:
+
+1. Explicit value (``--model`` / config / YAML) — handled by the caller.
+2. Most-recently-used model, persisted under ``~/.praison/state/model.json``.
+3. Best available model inferred from which provider credentials are present
+   (delegated to :func:`default_model_for_available_provider`).
+
+This is a wrapper/first-run concern: recency state, credential scanning and the
+one-line CLI notice live here, while core only owns a small provider-aware
+helper that maps present credentials to a default.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+from .paths import get_user_config_dir
+
+
+def _state_dir() -> Path:
+    """Return the user state directory (``~/.praison/state``)."""
+    return get_user_config_dir() / "state"
+
+
+def _model_state_path() -> Path:
+    """Return the recency file path (``~/.praison/state/model.json``)."""
+    return _state_dir() / "model.json"
+
+
+def get_recent_model() -> Optional[str]:
+    """Return the most-recently-used model, or ``None`` if not recorded."""
+    try:
+        path = _model_state_path()
+        if not path.exists():
+            return None
+        data = json.loads(path.read_text(encoding="utf-8"))
+        model = data.get("model")
+        return model if isinstance(model, str) and model else None
+    except Exception:
+        # Never let a corrupt/unreadable state file break model resolution.
+        return None
+
+
+def set_recent_model(model: Optional[str]) -> bool:
+    """Persist ``model`` as the most-recently-used model.
+
+    Returns ``True`` on success, ``False`` if persistence failed (e.g. a
+    read-only home directory). Failure is non-fatal — the model still works
+    for the current run, it just won't be remembered.
+    """
+    if not model:
+        return False
+    try:
+        state_dir = _state_dir()
+        state_dir.mkdir(parents=True, exist_ok=True)
+        _model_state_path().write_text(
+            json.dumps({"model": model}), encoding="utf-8"
+        )
+        return True
+    except Exception:
+        return False
+
+
+def _provider_for_model(model: str) -> Optional[str]:
+    """Best-effort map a model id to the credential env var that explains it."""
+    m = model.lower()
+    if m.startswith("anthropic/") or m.startswith("claude"):
+        return "ANTHROPIC_API_KEY"
+    if m.startswith("gemini/") or m.startswith("gemini"):
+        return "GEMINI_API_KEY"
+    if m.startswith("google/"):
+        return "GOOGLE_API_KEY"
+    if m.startswith("groq/"):
+        return "GROQ_API_KEY"
+    if m.startswith("cohere/"):
+        return "COHERE_API_KEY"
+    if m.startswith("ollama/"):
+        return "OLLAMA_HOST"
+    if (
+        m.startswith("gpt")
+        or m.startswith("o1")
+        or m.startswith("o3")
+        or m.startswith("o4")
+        or m.startswith("openai/")
+    ):
+        return "OPENAI_API_KEY"
+    return None
+
+
+def resolve_default_model(
+    explicit: Optional[str] = None,
+    *,
+    persist: bool = True,
+    notify: bool = True,
+) -> str:
+    """Resolve the default model for a zero-config run.
+
+    Precedence: ``explicit`` > recent (persisted) > ``MODEL_NAME`` /
+    ``OPENAI_MODEL_NAME`` > provider-aware best > ``gpt-4o-mini``.
+
+    Only *user-chosen* models (``explicit`` and the env overrides) are
+    persisted as the recent model. Provider-*inferred* defaults and the
+    ``gpt-4o-mini`` fallback are intentionally **not** persisted: persisting
+    them would let a stale inferred default short-circuit credential-based
+    inference on a later run after the user's available providers have changed.
+
+    Args:
+        explicit: An explicitly configured model (``--model``/config/YAML).
+            When given it wins and is persisted as the recent model.
+        persist: Whether to remember user-chosen models for next time.
+        notify: Whether to emit a one-line transparency notice the first time a
+            provider-aware default is inferred (no explicit, no recent model).
+
+    Returns:
+        The resolved model id.
+    """
+    if explicit:
+        if persist:
+            set_recent_model(explicit)
+        return explicit
+
+    recent = get_recent_model()
+    if recent:
+        return recent
+
+    # Honour OPENAI_MODEL_NAME / MODEL_NAME for backward compatibility before
+    # falling back to credential-based inference.
+    env_model = os.environ.get("MODEL_NAME") or os.environ.get("OPENAI_MODEL_NAME")
+    if env_model:
+        if persist:
+            set_recent_model(env_model)
+        return env_model
+
+    try:
+        from ...llm.env import default_model_for_available_provider
+        model = default_model_for_available_provider()
+    except Exception:
+        model = "gpt-4o-mini"
+
+    if notify:
+        provider = _provider_for_model(model)
+        if provider and os.environ.get(provider):
+            try:
+                import typer
+                typer.echo(
+                    f"No model set; using {model} because {provider} is present."
+                )
+            except Exception:
+                pass
+
+    # NOTE: provider-inferred defaults and the gpt-4o-mini fallback are
+    # deliberately NOT persisted. Persisting them would let a stale inferred
+    # default win over fresh credential-based inference on a later run when the
+    # user's available providers have changed, re-introducing the very
+    # zero-config failure this resolver exists to prevent.
+    return model