general-augment-cli 0.1.0__py3-none-any.whl

platform_cli/config.py

@@ -0,0 +1,114 @@
+"""Local CLI configuration stored in ~/.genaug/config.yaml."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field
+
+DEFAULT_BASE_URL = "https://api.generalaugment.com"
+CONFIG_PATH_ENV = "GENAUG_CLI_CONFIG"
+CONFIG_DIR = ".genaug"
+
+
+@dataclass(frozen=True)
+class ConfigPaths:
+    """Resolved config paths for reading existing auth and writing new auth."""
+
+    load_path: Path
+    save_path: Path
+
+
+class CLIConfig(BaseModel):
+    """Persisted CLI configuration."""
+
+    base_url: str = DEFAULT_BASE_URL
+    api_key: str | None = None
+    active_project: str | None = None
+    profile: str = "default"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+def default_config_path() -> Path:
+    """Return the preferred config path."""
+    override = _config_path_override()
+    if override:
+        return override
+    return Path.home() / CONFIG_DIR / "config.yaml"
+
+
+def resolve_config_paths(path: Path | None = None) -> ConfigPaths:
+    """Resolve read and write paths."""
+    if path:
+        resolved = path.expanduser()
+        return ConfigPaths(load_path=resolved, save_path=resolved)
+    override = _config_path_override()
+    if override:
+        return ConfigPaths(load_path=override, save_path=override)
+    preferred = default_config_path()
+    return ConfigPaths(load_path=preferred, save_path=preferred)
+
+
+def load_config(path: Path | None = None) -> CLIConfig:
+    """Load CLI config from disk or return defaults."""
+    resolved = path or default_config_path()
+    if not resolved.exists():
+        return CLIConfig()
+    payload = yaml.safe_load(resolved.read_text(encoding="utf-8")) or {}
+    if not isinstance(payload, dict):
+        return CLIConfig()
+    return CLIConfig.model_validate(payload)
+
+
+def save_config(config: CLIConfig, path: Path | None = None) -> Path:
+    """Write CLI config and return the path."""
+    resolved = path or default_config_path()
+    resolved.parent.mkdir(parents=True, exist_ok=True)
+    resolved.write_text(
+        yaml.safe_dump(config.model_dump(), sort_keys=False),
+        encoding="utf-8",
+    )
+    resolved.chmod(0o600)
+    return resolved
+
+
+def clear_config(path: Path | None = None) -> None:
+    """Remove the persisted config file when it exists."""
+    resolved = path or default_config_path()
+    if resolved.exists():
+        resolved.unlink()
+
+
+def apply_runtime_overrides(
+    config: CLIConfig,
+    *,
+    base_url: str | None = None,
+    api_key: str | None = None,
+) -> CLIConfig:
+    """Apply CLI flags and environment variables without mutating the stored config."""
+    return config.model_copy(
+        update={
+            "base_url": (
+                base_url
+                or os.getenv("GENAUG_ADMIN_BASE_URL")
+                or os.getenv("GENAUG_API_BASE_URL")
+                or config.base_url
+            ),
+            "api_key": (
+                api_key
+                or os.getenv("GENAUG_ADMIN_API_KEY")
+                or os.getenv("GENAUG_API_KEY")
+                or config.api_key
+            ),
+        }
+    )
+
+
+def _config_path_override() -> Path | None:
+    """Return a configured path."""
+    override = os.getenv(CONFIG_PATH_ENV)
+    return Path(override).expanduser() if override else None

platform_cli/errors.py

@@ -0,0 +1,103 @@
+"""CLI-specific error types and formatting."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import click
+
+
+class CLIError(click.ClickException):
+    """Base CLI error with a user-facing message."""
+
+
+class APIError(CLIError):
+    """Raised when the platform API returns an error."""
+
+    def __init__(
+        self,
+        status_code: int,
+        detail: Any,
+        headers: Mapping[str, str] | None = None,
+    ) -> None:
+        """Create an API error."""
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = dict(headers or {})
+        super().__init__(helpful_api_error(status_code, detail, self.headers))
+
+
+def helpful_api_error(
+    status_code: int,
+    detail: Any,
+    headers: Mapping[str, str] | None = None,
+) -> str:
+    """Return actionable API error text."""
+    if status_code == 401:
+        return "Your API key may be invalid. Run genaug auth login to re-authenticate."
+    if status_code == 403:
+        return f"You do not have access to this resource. API said: {_detail_message(detail)}"
+    if status_code == 404:
+        return (
+            "That resource was not found. Check the project or tool name. "
+            f"API said: {_detail_message(detail)}"
+        )
+    if status_code == 429:
+        return _rate_limit_message(detail, headers or {})
+    if status_code >= 500:
+        return (
+            "The platform API is having trouble. Retry shortly. "
+            f"API said: {_detail_message(detail)}"
+        )
+    return f"Platform API returned {status_code}: {_detail_message(detail)}"
+
+
+def _rate_limit_message(detail: Any, headers: Mapping[str, str]) -> str:
+    """Return a specific rate-limit explanation when the API provides one."""
+    reason = _detail_value(detail, "reason") or _detail_value(detail, "code")
+    retry_after = _header_value(headers, "Retry-After") or _detail_value(detail, "retry_after")
+    message = _detail_value(detail, "message")
+    parts = ["You are being rate limited."]
+    if retry_after:
+        parts.append(f"Retry after {retry_after} seconds.")
+    else:
+        parts.append("Wait a minute and retry the command.")
+    if reason:
+        parts.append(f"Reason: {reason}.")
+    if message and message != reason:
+        parts.append(f"API said: {message}")
+    return " ".join(parts)
+
+
+def _detail_value(detail: Any, key: str) -> str | None:
+    """Find a stable value in API error payloads."""
+    if not isinstance(detail, dict):
+        return None
+    candidates = [detail]
+    for nested_key in ("detail", "error"):
+        nested = detail.get(nested_key)
+        if isinstance(nested, dict):
+            candidates.append(nested)
+    for candidate in candidates:
+        value = candidate.get(key)
+        if value not in (None, ""):
+            return str(value)
+    return None
+
+
+def _header_value(headers: Mapping[str, str], key: str) -> str | None:
+    """Return a header value without depending on header casing."""
+    for header_key, value in headers.items():
+        if header_key.lower() == key.lower():
+            return value
+    return None
+
+
+def _detail_message(detail: Any) -> str:
+    """Return a readable API detail string."""
+    if isinstance(detail, dict):
+        message = _detail_value(detail, "message")
+        if message:
+            return message
+    return str(detail)