applied-cli 0.1.0__py3-none-any.whl

applied_cli/__init__.py

@@ -0,0 +1,2 @@
+"""applied-cli package."""
+

applied_cli/auth_store.py

@@ -0,0 +1,263 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+from applied_cli.config import Credentials
+
+SERVICE_NAME = "applied-cli"
+ACCOUNT_NAME = "default"
+STORE_VERSION = 2
+
+
+def _fallback_path() -> Path:
+    return Path.home() / ".config" / "applied-cli" / "credentials.json"
+
+
+def _credentials_to_dict(credentials: Credentials) -> dict[str, str]:
+    return {
+        "base_url": credentials.base_url,
+        "shop_id": credentials.shop_id,
+        "api_token": credentials.api_token,
+    }
+
+
+def _credentials_from_dict(data: dict[str, object]) -> Optional[Credentials]:
+    base_url = str(data.get("base_url", "")).strip()
+    shop_id = str(data.get("shop_id", "")).strip()
+    api_token = str(data.get("api_token", "")).strip()
+    if not base_url or not shop_id or not api_token:
+        return None
+    return Credentials(base_url=base_url, shop_id=shop_id, api_token=api_token)
+
+
+def _normalize_store(raw: object) -> dict[str, object]:
+    if not isinstance(raw, dict):
+        return {"version": STORE_VERSION, "active_profile": None, "profiles": {}}
+
+    # Legacy single-profile shape:
+    # {"base_url": "...", "shop_id": "...", "api_token": "..."}
+    legacy = _credentials_from_dict(raw)
+    if legacy:
+        return {
+            "version": STORE_VERSION,
+            "active_profile": "default",
+            "profiles": {"default": _credentials_to_dict(legacy)},
+        }
+
+    profiles_raw = raw.get("profiles")
+    profiles: dict[str, dict[str, str]] = {}
+    if isinstance(profiles_raw, dict):
+        for profile_name, payload in profiles_raw.items():
+            if not isinstance(profile_name, str) or not profile_name.strip():
+                continue
+            if not isinstance(payload, dict):
+                continue
+            creds = _credentials_from_dict(payload)
+            if creds is None:
+                continue
+            profiles[profile_name.strip()] = _credentials_to_dict(creds)
+
+    active_profile_raw = raw.get("active_profile")
+    active_profile = (
+        active_profile_raw.strip()
+        if isinstance(active_profile_raw, str) and active_profile_raw.strip()
+        else None
+    )
+    if active_profile and active_profile not in profiles:
+        active_profile = None
+    if not active_profile and profiles:
+        active_profile = sorted(profiles.keys())[0]
+
+    return {
+        "version": STORE_VERSION,
+        "active_profile": active_profile,
+        "profiles": profiles,
+    }
+
+
+def _serialize_store(store: dict[str, object]) -> str:
+    return json.dumps(
+        {
+            "version": STORE_VERSION,
+            "active_profile": store.get("active_profile"),
+            "profiles": store.get("profiles", {}),
+        }
+    )
+
+
+def _load_store_from_keyring() -> Optional[dict[str, object]]:
+    try:
+        import keyring
+    except Exception:
+        return None
+
+    try:
+        raw = keyring.get_password(SERVICE_NAME, ACCOUNT_NAME)
+    except Exception:
+        return None
+
+    if not raw:
+        return None
+
+    try:
+        return _normalize_store(json.loads(raw))
+    except Exception:
+        return None
+
+
+def _save_store_to_keyring(store: dict[str, object]) -> bool:
+    try:
+        import keyring
+    except Exception:
+        return False
+
+    try:
+        keyring.set_password(
+            SERVICE_NAME,
+            ACCOUNT_NAME,
+            _serialize_store(store),
+        )
+        return True
+    except Exception:
+        return False
+
+
+def _clear_keyring() -> None:
+    try:
+        import keyring
+
+        keyring.delete_password(SERVICE_NAME, ACCOUNT_NAME)
+    except Exception:
+        return
+
+
+def _load_store_from_file() -> Optional[dict[str, object]]:
+    path = _fallback_path()
+    if not path.exists():
+        return None
+
+    try:
+        return _normalize_store(json.loads(path.read_text()))
+    except Exception:
+        return None
+
+
+def _save_store_to_file(store: dict[str, object]) -> None:
+    path = _fallback_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(_serialize_store(store))
+    path.chmod(0o600)
+
+
+def _clear_file() -> None:
+    path = _fallback_path()
+    if path.exists():
+        path.unlink()
+
+
+def _load_store() -> dict[str, object]:
+    store = _load_store_from_keyring()
+    if store:
+        return store
+    store = _load_store_from_file()
+    if store:
+        return store
+    return {"version": STORE_VERSION, "active_profile": None, "profiles": {}}
+
+
+def _save_store(store: dict[str, object]) -> str:
+    if _save_store_to_keyring(store):
+        return "keyring"
+
+    _save_store_to_file(store)
+    return "file"
+
+
+def save_credentials(
+    credentials: Credentials,
+    *,
+    profile: str = "default",
+    set_active: bool = True,
+) -> str:
+    profile_name = profile.strip() or "default"
+    store = _load_store()
+    profiles = store.get("profiles")
+    if not isinstance(profiles, dict):
+        profiles = {}
+    profiles[profile_name] = _credentials_to_dict(credentials)
+    store["profiles"] = profiles
+    if set_active:
+        store["active_profile"] = profile_name
+    return _save_store(store)
+
+
+def load_profiles() -> dict[str, Credentials]:
+    store = _load_store()
+    profiles = store.get("profiles")
+    if not isinstance(profiles, dict):
+        return {}
+    out: dict[str, Credentials] = {}
+    for profile_name, payload in profiles.items():
+        if not isinstance(profile_name, str) or not isinstance(payload, dict):
+            continue
+        creds = _credentials_from_dict(payload)
+        if creds is not None:
+            out[profile_name] = creds
+    return out
+
+
+def list_profiles() -> list[str]:
+    return sorted(load_profiles().keys())
+
+
+def get_active_profile_name() -> Optional[str]:
+    store = _load_store()
+    active = store.get("active_profile")
+    return active if isinstance(active, str) and active.strip() else None
+
+
+def set_active_profile(profile: str) -> bool:
+    profile_name = profile.strip()
+    if not profile_name:
+        return False
+    store = _load_store()
+    profiles = store.get("profiles")
+    if not isinstance(profiles, dict) or profile_name not in profiles:
+        return False
+    store["active_profile"] = profile_name
+    _save_store(store)
+    return True
+
+
+def delete_profile(profile: str) -> bool:
+    profile_name = profile.strip()
+    if not profile_name:
+        return False
+    store = _load_store()
+    profiles = store.get("profiles")
+    if not isinstance(profiles, dict) or profile_name not in profiles:
+        return False
+    del profiles[profile_name]
+    store["profiles"] = profiles
+    active = store.get("active_profile")
+    if active == profile_name:
+        store["active_profile"] = sorted(profiles.keys())[0] if profiles else None
+    _save_store(store)
+    return True
+
+
+def load_credentials(*, profile: Optional[str] = None) -> Optional[Credentials]:
+    profiles = load_profiles()
+    if not profiles:
+        return None
+    if profile and profile in profiles:
+        return profiles[profile]
+    active = get_active_profile_name()
+    if active and active in profiles:
+        return profiles[active]
+    return profiles.get("default")
+
+
+def clear_credentials() -> None:
+    _clear_keyring()
+    _clear_file()

applied_cli/commands/__init__.py

@@ -0,0 +1,2 @@
+"""CLI command groups."""
+

applied_cli/commands/_hints.py

@@ -0,0 +1,11 @@
+from difflib import get_close_matches
+from typing import Iterable
+
+
+def suggest_value(raw: str, options: Iterable[str]) -> str | None:
+    value = raw.strip().lower()
+    normalized = [item.strip().lower() for item in options if item.strip()]
+    if not value or not normalized:
+        return None
+    matches = get_close_matches(value, normalized, n=1, cutoff=0.6)
+    return matches[0] if matches else None

applied_cli/commands/_normalize.py

@@ -0,0 +1,79 @@
+import re
+from typing import Optional
+
+import typer
+
+from applied_cli.commands._hints import suggest_value
+
+MODALITY_ALIASES = {
+    "all": "All",
+    "call": "Call",
+    "sms": "SMS",
+    "email": "Email",
+    "chat": "Chat",
+    "internal": "Internal",
+}
+
+AGENT_TYPE_ALIASES = {
+    "generic": "Generic",
+    "customer_support": "Customer Support",
+    "customer support": "Customer Support",
+    "conversion": "Conversion",
+    "sales": "Sales",
+    "marketing": "Marketing",
+    "engineering": "Engineering",
+    "product": "Product",
+}
+
+RESPONSE_TYPE_ALIASES = {
+    "escalation": "escalate",
+    "escalate": "escalate",
+    "exact": "exact",
+    "qa": "qa",
+    "context": "context",
+    "greeting": "greeting",
+    "signature": "signature",
+}
+
+
+def normalize_question(text: str) -> str:
+    return re.sub(r"\s+", " ", text.strip().lower())
+
+
+def normalize_response_type(
+    raw: str,
+    *,
+    field_label: str = "type",
+    include_suggestion: bool = False,
+) -> str:
+    key = raw.strip().lower()
+    if key not in RESPONSE_TYPE_ALIASES:
+        suffix = ""
+        if include_suggestion:
+            suggestion = suggest_value(key, RESPONSE_TYPE_ALIASES.keys())
+            if suggestion:
+                suffix = f" Did you mean '{suggestion}'?"
+        raise typer.BadParameter(
+            f"{field_label} must be one of: escalation, exact, qa, context, greeting, signature.{suffix}"
+        )
+    return RESPONSE_TYPE_ALIASES[key]
+
+
+def normalize_modality(raw: Optional[str]) -> Optional[str]:
+    if raw is None:
+        return None
+    key = raw.strip().lower()
+    if key not in MODALITY_ALIASES:
+        raise typer.BadParameter("modality must be one of: all, call, sms, email, chat, internal")
+    return MODALITY_ALIASES[key]
+
+
+def normalize_agent_type(raw: Optional[str]) -> Optional[str]:
+    if raw is None:
+        return None
+    key = raw.strip().lower()
+    if key not in AGENT_TYPE_ALIASES:
+        raise typer.BadParameter(
+            "type must be one of: generic, customer_support, conversion, sales, marketing, engineering, product"
+        )
+    return AGENT_TYPE_ALIASES[key]

applied_cli/commands/_parsers.py

@@ -0,0 +1,58 @@
+import json
+import uuid
+from typing import Any, Optional
+
+import typer
+
+
+def validate_uuid(value: str, *, field_name: str) -> None:
+    try:
+        uuid.UUID(value)
+    except ValueError as exc:
+        raise typer.BadParameter(f"{field_name} must be a valid UUID.") from exc
+
+
+def parse_optional_bool(raw: Optional[str], *, field_name: str) -> Optional[bool]:
+    if raw is None:
+        return None
+    normalized = raw.strip().lower()
+    if normalized in {"1", "true", "t", "yes", "y"}:
+        return True
+    if normalized in {"0", "false", "f", "no", "n"}:
+        return False
+    raise typer.BadParameter(f"{field_name} expected one of: true/false/1/0/yes/no")
+
+
+def parse_json_dict(raw: Optional[str], *, field_name: str) -> Optional[dict[str, Any]]:
+    if raw is None:
+        return None
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"{field_name} must be valid JSON.") from exc
+    if not isinstance(parsed, dict):
+        raise typer.BadParameter(f"{field_name} must decode to a JSON object.")
+    return parsed
+
+
+def parse_json_array(raw: Optional[str], *, field_name: str) -> Optional[list[Any]]:
+    if raw is None:
+        return None
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"{field_name} must be valid JSON.") from exc
+    if not isinstance(parsed, list):
+        raise typer.BadParameter(f"{field_name} must decode to a JSON array.")
+    return parsed
+
+
+def parse_csv_list(raw: Optional[str]) -> list[str]:
+    if not raw:
+        return []
+    return [token.strip() for token in raw.split(",") if token.strip()]
+
+
+def validate_uuid_list(values: list[str], *, field_name: str) -> None:
+    for value in values:
+        validate_uuid(value, field_name=field_name)

applied_cli/commands/_ui.py

@@ -0,0 +1,33 @@
+import json
+from typing import Any
+
+import typer
+
+
+def show_target(fields: dict[str, Any]) -> None:
+    typer.echo("Target:")
+    for key, value in fields.items():
+        typer.echo(f"- {key}: {value}")
+
+
+def confirm_or_exit(*, yes: bool, prompt: str = "Continue?") -> None:
+    if not yes and not typer.confirm(prompt):
+        raise typer.Exit(code=1)
+
+
+def emit_dry_run(*, payload: dict[str, Any], output_json: bool) -> None:
+    typer.echo(json.dumps(payload, indent=2) if output_json else str(payload))
+    raise typer.Exit(code=0)
+
+
+def emit_success(
+    *,
+    output_json: bool,
+    payload: Any,
+    fields: dict[str, Any],
+) -> None:
+    if output_json:
+        typer.echo(json.dumps(payload, indent=2, default=str))
+        return
+    items = [f"{key}={value}" for key, value in fields.items()]
+    typer.echo("result=success | " + " | ".join(items))