applied-cli 0.1.0__tar.gz

applied_cli-0.1.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: applied-cli
+Version: 0.1.0
+Summary: CLI and MCP server for Applied Labs AI support agents
+Author: Applied Labs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/appliedlabs/applied-cli
+Project-URL: Repository, https://github.com/appliedlabs/applied-cli
+Keywords: applied-labs,ai-agents,support,mcp,claude
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: typer>=0.16.0
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2.0; extra == "mcp"
+
+# Applied Labs CLI
+
+CLI and Claude Code plugin for managing Applied Labs AI support agents.
+
+## Installation
+
+### As a Claude Code Plugin
+
+```bash
+# From a marketplace (once published)
+/plugin install applied-labs@marketplace-name
+
+# Or test locally
+claude --plugin-dir /path/to/applied-cli
+```
+
+### As a standalone CLI
+
+```bash
+pip install applied-cli
+
+# Or with MCP server support
+pip install "applied-cli[mcp]"
+```
+
+## Authentication
+
+```bash
+applied-cli auth login          # Opens browser for approval
+applied-cli auth status         # Check current shop
+applied-cli auth shops          # List available shops
+applied-cli auth use-shop NAME  # Switch shops
+```
+
+## Quick Start
+
+### 1. Set up a new shop
+
+```bash
+# Generate spec template
+applied-cli shop template > my-shop.yaml
+
+# Edit the spec with your configuration...
+
+# Run setup
+applied-cli shop setup --spec my-shop.yaml --json
+```
+
+### 2. Test your agent
+
+```bash
+applied-cli chat --agent-id <uuid> --message "Hello"
+```
+
+### 3. Fix failing scenarios
+
+```bash
+# Get context for failures
+applied-cli test fix context --benchmark-id <uuid> --json
+
+# Update knowledge base
+applied-cli knowledge upsert --agent-id <uuid> --type qa \
+  --question "What is your return policy?" \
+  --answer "30 day returns on all items."
+
+# Batch test fixes
+applied-cli test fix batch --source <failing-benchmark> --target <validation-benchmark>
+
+# Check progress
+applied-cli test fix status --source <source> --target <target>
+```
+
+## Command Reference
+
+```
+applied-cli
+├── auth            # Login, logout, switch shops
+├── shop            # Bootstrap new shops from YAML spec
+├── agent           # List, create, update agents
+├── chat            # Send a message to an agent
+├── conversations   # List, show, import conversations
+├── insights        # Generate analytics reports
+├── knowledge       # Q&A entries, escalation rules
+├── taxonomy        # Topic/intent classification
+├── test            # Testing workflows
+│   ├── benchmarks  # Scenario collections
+│   ├── scenarios   # Individual test cases (includes rate)
+│   ├── runs        # Execution records
+│   ├── coverage    # Coverage summaries
+│   └── fix         # Fix failing scenarios
+└── simulate        # Generate test conversations
+```
+
+## MCP Server
+
+The CLI includes an MCP server for Claude integrations:
+
+```bash
+# Run directly (after pip install)
+applied-cli-mcp
+
+# Or via uvx (after publishing to PyPI)
+uvx --from "applied-cli[mcp]" applied-cli-mcp
+```
+
+### Claude Desktop Configuration
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "applied-labs": {
+      "command": "applied-cli-mcp"
+    }
+  }
+}
+```
+
+## Plugin Skills
+
+When installed as a Claude Code plugin, these skills are available:
+
+- `/applied-labs:setup-shop` - Guided shop setup workflow
+- `/applied-labs:fix-scenarios` - Fix failing test scenarios
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `APPLIED_ENDPOINT` | `prod`, `dev`, `local`, or full URL |
+| `APPLIED_SHOP_ID` | Pre-select shop UUID |
+| `APPLIED_API_TOKEN` | Skip browser auth |
+| `APPLIED_PROFILE` | Named credential profile |
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e ".[mcp]"
+
+# Test CLI
+applied-cli --help
+
+# Test MCP server
+applied-cli-mcp
+
+# Test as Claude Code plugin
+claude --plugin-dir .
+```
+
+## License
+
+MIT

applied_cli-0.1.0/README.md

@@ -0,0 +1,154 @@
+# Applied Labs CLI
+
+CLI and Claude Code plugin for managing Applied Labs AI support agents.
+
+## Installation
+
+### As a Claude Code Plugin
+
+```bash
+# From a marketplace (once published)
+/plugin install applied-labs@marketplace-name
+
+# Or test locally
+claude --plugin-dir /path/to/applied-cli
+```
+
+### As a standalone CLI
+
+```bash
+pip install applied-cli
+
+# Or with MCP server support
+pip install "applied-cli[mcp]"
+```
+
+## Authentication
+
+```bash
+applied-cli auth login          # Opens browser for approval
+applied-cli auth status         # Check current shop
+applied-cli auth shops          # List available shops
+applied-cli auth use-shop NAME  # Switch shops
+```
+
+## Quick Start
+
+### 1. Set up a new shop
+
+```bash
+# Generate spec template
+applied-cli shop template > my-shop.yaml
+
+# Edit the spec with your configuration...
+
+# Run setup
+applied-cli shop setup --spec my-shop.yaml --json
+```
+
+### 2. Test your agent
+
+```bash
+applied-cli chat --agent-id <uuid> --message "Hello"
+```
+
+### 3. Fix failing scenarios
+
+```bash
+# Get context for failures
+applied-cli test fix context --benchmark-id <uuid> --json
+
+# Update knowledge base
+applied-cli knowledge upsert --agent-id <uuid> --type qa \
+  --question "What is your return policy?" \
+  --answer "30 day returns on all items."
+
+# Batch test fixes
+applied-cli test fix batch --source <failing-benchmark> --target <validation-benchmark>
+
+# Check progress
+applied-cli test fix status --source <source> --target <target>
+```
+
+## Command Reference
+
+```
+applied-cli
+├── auth            # Login, logout, switch shops
+├── shop            # Bootstrap new shops from YAML spec
+├── agent           # List, create, update agents
+├── chat            # Send a message to an agent
+├── conversations   # List, show, import conversations
+├── insights        # Generate analytics reports
+├── knowledge       # Q&A entries, escalation rules
+├── taxonomy        # Topic/intent classification
+├── test            # Testing workflows
+│   ├── benchmarks  # Scenario collections
+│   ├── scenarios   # Individual test cases (includes rate)
+│   ├── runs        # Execution records
+│   ├── coverage    # Coverage summaries
+│   └── fix         # Fix failing scenarios
+└── simulate        # Generate test conversations
+```
+
+## MCP Server
+
+The CLI includes an MCP server for Claude integrations:
+
+```bash
+# Run directly (after pip install)
+applied-cli-mcp
+
+# Or via uvx (after publishing to PyPI)
+uvx --from "applied-cli[mcp]" applied-cli-mcp
+```
+
+### Claude Desktop Configuration
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "applied-labs": {
+      "command": "applied-cli-mcp"
+    }
+  }
+}
+```
+
+## Plugin Skills
+
+When installed as a Claude Code plugin, these skills are available:
+
+- `/applied-labs:setup-shop` - Guided shop setup workflow
+- `/applied-labs:fix-scenarios` - Fix failing test scenarios
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `APPLIED_ENDPOINT` | `prod`, `dev`, `local`, or full URL |
+| `APPLIED_SHOP_ID` | Pre-select shop UUID |
+| `APPLIED_API_TOKEN` | Skip browser auth |
+| `APPLIED_PROFILE` | Named credential profile |
+
+## Development
+
+```bash
+# Install in development mode
+pip install -e ".[mcp]"
+
+# Test CLI
+applied-cli --help
+
+# Test MCP server
+applied-cli-mcp
+
+# Test as Claude Code plugin
+claude --plugin-dir .
+```
+
+## License
+
+MIT

applied_cli-0.1.0/applied_cli/__init__.py

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

applied_cli-0.1.0/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-0.1.0/applied_cli/commands/__init__.py

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

applied_cli-0.1.0/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-0.1.0/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]