applied-cli 0.5.74__tar.gz → 0.6.1__tar.gz

{applied_cli-0.5.74 → applied_cli-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.74
+Version: 0.6.1
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
 Requires-Dist: typer>=0.9.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"

applied_cli-0.6.1/applied_cli/__init__.py

@@ -0,0 +1,20 @@
+"""Applied Labs CLI - shared client library for CLI and MCP server."""
+
+from applied_cli import tools
+from applied_cli.auth import AuthContext
+from applied_cli.client import AppliedClient
+from applied_cli.formatters import to_csv, to_json
+from applied_cli.toolkit import ToolResult, ToolSpec
+
+__version__ = "0.6.0"
+
+__all__ = [
+    "AppliedClient",
+    "AuthContext",
+    "ToolResult",
+    "ToolSpec",
+    "tools",
+    "to_csv",
+    "to_json",
+    "__version__",
+]

applied_cli-0.6.1/applied_cli/auth.py

@@ -0,0 +1,111 @@
+"""Shared authentication context for local CLI and MCP-injected sessions."""
+
+from __future__ import annotations
+
+import os
+from typing import Protocol
+
+from pydantic import BaseModel
+
+from applied_cli.client import AppliedAPIError, AppliedClient
+from applied_cli.credentials import load_credentials
+
+DEFAULT_BASE_URL = "https://api.appliedlabs.ai"
+
+
+class AuthStatus(BaseModel):
+    ok: bool
+    shop_id: str | None = None
+    base_url: str = DEFAULT_BASE_URL
+    message: str
+    status_code: int | None = None
+
+
+class AuthContext(BaseModel):
+    token: str
+    shop_id: str | None = None
+    base_url: str = DEFAULT_BASE_URL
+    access_mode: str | None = None
+
+    def to_client(self) -> AppliedClient:
+        return AppliedClient(
+            token=self.token,
+            shop_id=self.shop_id,
+            base_url=self.base_url,
+            access_mode=self.access_mode,
+        )
+
+    async def validate(self) -> AuthStatus:
+        client = self.to_client()
+        try:
+            await client.request(
+                "GET",
+                "/v1/agents/",
+                params={"limit": 1},
+                shop_id=self.shop_id,
+            )
+        except AppliedAPIError as exc:
+            return AuthStatus(
+                ok=False,
+                shop_id=self.shop_id,
+                base_url=self.base_url,
+                message=str(exc),
+                status_code=exc.status_code,
+            )
+        return AuthStatus(
+            ok=True,
+            shop_id=self.shop_id,
+            base_url=self.base_url,
+            message="Authenticated.",
+        )
+
+
+class CredentialProvider(Protocol):
+    def load(self) -> AuthContext | None:
+        ...
+
+
+class EnvCredentialProvider:
+    """Load credentials from environment variables for automation/MCP smoke tests."""
+
+    def load(self) -> AuthContext | None:
+        token = os.environ.get("APPLIED_TOKEN") or os.environ.get("APPLIED_API_TOKEN")
+        if not token:
+            return None
+        return AuthContext(
+            token=token,
+            shop_id=os.environ.get("APPLIED_SHOP_ID"),
+            base_url=os.environ.get("APPLIED_BASE_URL", DEFAULT_BASE_URL),
+            access_mode=os.environ.get("APPLIED_ASSISTANT_ACCESS_MODE"),
+        )
+
+
+class StoredCredentialProvider:
+    """Load credentials written by `applied login`."""
+
+    def load(self) -> AuthContext | None:
+        credentials = load_credentials()
+        if not credentials or not credentials.get("api_token"):
+            return None
+        return AuthContext(
+            token=credentials["api_token"],
+            shop_id=credentials.get("shop_id"),
+            base_url=credentials.get("base_url", DEFAULT_BASE_URL),
+            access_mode=os.environ.get("APPLIED_ASSISTANT_ACCESS_MODE"),
+        )
+
+
+class ChainedCredentialProvider:
+    def __init__(self, *providers: CredentialProvider):
+        self.providers = providers
+
+    def load(self) -> AuthContext | None:
+        for provider in self.providers:
+            context = provider.load()
+            if context:
+                return context
+        return None
+
+
+def default_credential_provider() -> CredentialProvider:
+    return ChainedCredentialProvider(EnvCredentialProvider(), StoredCredentialProvider())

{applied_cli-0.5.74 → applied_cli-0.6.1}/applied_cli/cli.py

@@ -10,12 +10,21 @@ import typer
 
 from applied_cli import __version__, tools
 from applied_cli.agent_scoped_flows import run_agent_scoped_flow_command
+from applied_cli.auth import AuthContext, default_credential_provider
 from applied_cli.client import AppliedClient
 from applied_cli.credentials import (
     clear_credentials,
     load_credentials,
     save_credentials,
 )
+from applied_cli.toolkit import render_tool_result
+from applied_cli.v2.catalog import (
+    execute_tool as execute_v2_tool,
+)
+from applied_cli.v2.catalog import (
+    get_tool_catalog,
+)
+from applied_cli.v2.manifest import build_doctor_report, build_tool_manifest
 
 app = typer.Typer(
     name="applied",
@@ -24,9 +33,24 @@ app = typer.Typer(
 )
 content_app = typer.Typer(help="Inspect synced content items.")
 app.add_typer(content_app, name="content")
+v2_app = typer.Typer(help="Run v2 typed Applied tools.")
+v2_tools_app = typer.Typer(help="Inspect v2 tool schemas.")
+v2_conversations_app = typer.Typer(help="Conversation tools.")
+v2_app.add_typer(v2_tools_app, name="tools")
+v2_app.add_typer(v2_conversations_app, name="conversations")
+app.add_typer(v2_app, name="v2")
 
 DEFAULT_BASE_URL = "https://api.appliedlabs.ai"
 DEFAULT_CLIENT_URL = "https://appliedlabs.ai"
+DEFAULT_RECOVERY_DIR_OPTION = typer.Option(
+    "/tmp/applied-labs-recovery-jun4-1915",
+    "--recovery-dir",
+    help="Directory containing exports/ and deleted_only/ recovery files",
+)
+AGENT_DEPLOY_AGENT_IDS_ARGUMENT = typer.Argument(
+    ...,
+    help="One or more Agent IDs to deploy",
+)
 
 
 def _version_callback(value: bool) -> None:
@@ -144,6 +168,47 @@ def _build_conversation_filters(
     return filters or None
 
 
+def _v2_auth_context() -> AuthContext | None:
+    return default_credential_provider().load()
+
+
+def _parse_v2_input(value: str | None) -> dict:
+    if not value:
+        return {}
+    parsed = _parse_json_option(value, option_name="--input")
+    return parsed or {}
+
+
+def _v2_tool_metadata(include_debug: bool = False) -> list[dict]:
+    return [
+        {
+            "name": spec.name,
+            "namespace": spec.namespace,
+            "description": spec.description,
+            "read_write_mode": spec.read_write_mode,
+            "tags": spec.tags,
+        }
+        for spec in get_tool_catalog(include_debug=include_debug)
+    ]
+
+
+def _v2_tool_detail(tool_name: str, include_debug: bool = False) -> dict:
+    catalog = get_tool_catalog(include_debug=include_debug)
+    spec = catalog.get(tool_name)
+    if spec is None:
+        typer.echo(f"Unknown v2 tool: {tool_name}", err=True)
+        raise typer.Exit(1)
+    return {
+        "name": spec.name,
+        "namespace": spec.namespace,
+        "description": spec.description,
+        "read_write_mode": spec.read_write_mode,
+        "tags": spec.tags,
+        "examples": spec.examples,
+        "input_schema": spec.input_schema(),
+    }
+
+
 # -----------------------------------------------------------------------------
 # Auth commands
 # -----------------------------------------------------------------------------
@@ -230,7 +295,13 @@ def logout() -> None:
 
 
 @app.command()
-def whoami() -> None:
+def whoami(
+    verify: bool = typer.Option(
+        True,
+        "--verify/--no-verify",
+        help="Verify the token against the Applied API.",
+    ),
+) -> None:
     """Show current authentication status."""
     creds = load_credentials()
     if not creds or not creds.get("api_token"):
@@ -243,6 +314,189 @@ def whoami() -> None:
     typer.echo(f"Base URL: {creds.get('base_url', DEFAULT_BASE_URL)}")
     if creds.get("shop_id"):
         typer.echo(f"Shop ID: {creds['shop_id']}")
+    if verify:
+        context = AuthContext(
+            token=creds["api_token"],
+            shop_id=creds.get("shop_id"),
+            base_url=creds.get("base_url", DEFAULT_BASE_URL),
+        )
+        status = asyncio.run(context.validate())
+        typer.echo(f"Verified: {'yes' if status.ok else 'no'}")
+        if not status.ok:
+            typer.echo(status.message, err=True)
+            raise typer.Exit(1)
+
+
+@v2_conversations_app.command("search")
+def v2_conversations_search(
+    search: str | None = typer.Option(None, "--search", help="Full-text search query"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Max conversations"),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Render the structured tool result as JSON.",
+    ),
+) -> None:
+    """Search conversations through the v2 typed tool catalog."""
+
+    async def _run():
+        return await execute_v2_tool(
+            "conversations_search",
+            {"search": search, "limit": limit},
+            auth_context=_v2_auth_context(),
+        )
+
+    result = asyncio.run(_run())
+    typer.echo(render_tool_result(result, "json" if json_output else "text"))
+
+
+@v2_tools_app.command("list")
+def v2_tools_list(
+    include_debug: bool = typer.Option(
+        False,
+        "--include-debug",
+        help="Include gated debug tools.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Render tool metadata as JSON.",
+    ),
+) -> None:
+    """List registered v2 Applied tools."""
+    payload = {"tools": _v2_tool_metadata(include_debug=include_debug)}
+    if json_output:
+        typer.echo(json.dumps(payload, indent=2, default=str))
+        return
+
+    for row in payload["tools"]:
+        first_line = row["description"].splitlines()[0]
+        typer.echo(
+            f"{row['name']}\t{row['read_write_mode']}\t{row['namespace']}\t{first_line}"
+        )
+
+
+@v2_tools_app.command("describe")
+def v2_tools_describe(
+    tool_name: str = typer.Argument(..., help="v2 tool name"),
+    include_debug: bool = typer.Option(
+        False,
+        "--include-debug",
+        help="Include gated debug tools.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Render schema as JSON.",
+    ),
+) -> None:
+    """Describe one v2 Applied tool and its input schema."""
+    payload = _v2_tool_detail(tool_name, include_debug=include_debug)
+    if json_output:
+        typer.echo(json.dumps(payload, indent=2, default=str))
+        return
+
+    typer.echo(f"{payload['name']} ({payload['read_write_mode']})")
+    typer.echo(payload["description"])
+    typer.echo(json.dumps(payload["input_schema"], indent=2, default=str))
+
+
+@v2_tools_app.command("manifest")
+def v2_tools_manifest(
+    include_debug: bool = typer.Option(
+        False,
+        "--include-debug",
+        help="Include gated debug tools.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Render the complete manifest as JSON.",
+    ),
+) -> None:
+    """Emit the complete v2 tool manifest for agents and MCP packaging."""
+    payload = build_tool_manifest(include_debug=include_debug)
+    if json_output:
+        typer.echo(json.dumps(payload, indent=2, default=str))
+        return
+
+    typer.echo(
+        f"Applied CLI v2 manifest: {payload['tool_count']} tools "
+        f"across {len(payload['namespace_counts'])} namespaces"
+    )
+    for name, count in payload["namespace_counts"].items():
+        typer.echo(f"{name}\t{count}")
+
+
+@v2_app.command("doctor")
+def v2_doctor(
+    include_debug: bool = typer.Option(
+        False,
+        "--include-debug",
+        help="Include gated debug tools in the catalog check.",
+    ),
+    validate_auth: bool = typer.Option(
+        False,
+        "--validate-auth",
+        help="Verify configured credentials against the Applied API.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Render diagnostics as JSON.",
+    ),
+) -> None:
+    """Check v2 catalog, MCP registration, and optional auth readiness."""
+
+    async def _run():
+        return await build_doctor_report(
+            include_debug=include_debug,
+            validate_auth=validate_auth,
+            credential_provider=default_credential_provider(),
+        )
+
+    payload = asyncio.run(_run())
+    if json_output:
+        typer.echo(json.dumps(payload, indent=2, default=str))
+        return
+
+    auth = payload["auth"]
+    typer.echo(f"Applied CLI {payload['version']}")
+    typer.echo(f"Catalog tools: {payload['catalog']['tool_count']}")
+    typer.echo(f"MCP registrar: {payload['mcp']['registrar']}")
+    typer.echo(f"Auth configured: {'yes' if auth['configured'] else 'no'}")
+    if validate_auth:
+        typer.echo(f"Auth valid: {'yes' if auth['ok'] else 'no'}")
+        if auth["message"]:
+            typer.echo(auth["message"])
+
+
+@v2_app.command("run")
+def v2_run(
+    tool_name: str = typer.Argument(..., help="v2 tool name"),
+    input_json: str | None = typer.Option(
+        None,
+        "--input",
+        "-i",
+        help="JSON object input for the tool.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Render the structured tool result as JSON.",
+    ),
+) -> None:
+    """Run any v2 Applied tool by name with JSON input."""
+
+    async def _run():
+        return await execute_v2_tool(
+            tool_name,
+            _parse_v2_input(input_json),
+            auth_context=_v2_auth_context(),
+        )
+
+    result = asyncio.run(_run())
+    typer.echo(render_tool_result(result, "json" if json_output else "text"))
 
 
 # -----------------------------------------------------------------------------
@@ -1343,6 +1597,49 @@ def benchmark_create(
     typer.echo(result)
 
 
+@app.command("benchmark-clone")
+def benchmark_clone(
+    source_benchmark_id: str = typer.Argument(
+        ..., help="Benchmark to copy scenarios from"
+    ),
+    dest_benchmark_id: str = typer.Option(
+        None, "--dest-benchmark-id", help="Existing destination benchmark UUID"
+    ),
+    dest_benchmark_name: str = typer.Option(
+        None,
+        "--dest-benchmark-name",
+        help="Destination benchmark name (found or created under --target-agent-id)",
+    ),
+    target_agent_id: str = typer.Option(
+        None,
+        "--target-agent-id",
+        help="Agent for the destination benchmark when created by name "
+        "(e.g. port an email benchmark onto the chat agent)",
+    ),
+    apply: bool = typer.Option(
+        False, "--apply", help="Write changes (default is a dry-run plan)"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+) -> None:
+    """Copy all scenarios from one benchmark into another (e.g. email -> chat)."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.benchmark_clone(
+            client,
+            source_benchmark_id=source_benchmark_id,
+            dest_benchmark_id=dest_benchmark_id,
+            dest_benchmark_name=dest_benchmark_name,
+            target_agent_id=target_agent_id,
+            dry_run=not apply,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
 @app.command()
 def scenarios(
     benchmark_id: str = typer.Option(
@@ -1523,6 +1820,59 @@ def scenario_run_update_cmd(
     typer.echo(result)
 
 
+@app.command("scenario-recover-catalog")
+def scenario_recover_catalog(
+    recovery_dir: Path = DEFAULT_RECOVERY_DIR_OPTION,
+    apply: bool = typer.Option(
+        False,
+        "--apply",
+        help="Create missing benchmarks/scenarios and restore rated runs",
+    ),
+    restore_ratings: bool = typer.Option(
+        True,
+        "--restore-ratings/--no-restore-ratings",
+        help="Restore rated scenario runs linked to recovered scenarios",
+    ),
+    max_rated_runs: int | None = typer.Option(
+        None,
+        "--max-rated-runs",
+        help="Cap rated run restore count for staged recovery",
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+    format: str = typer.Option(
+        "json", "--format", "-f", help="Output format: json or text"
+    ),
+) -> None:
+    """Recover deleted benchmark/scenario catalog rows from local PITR exports."""
+    from applied_cli.recovery import recover_scenario_catalog
+
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        recover_scenario_catalog(
+            client,
+            recovery_dir=recovery_dir,
+            dry_run=not apply,
+            restore_ratings=restore_ratings,
+            max_rated_runs=max_rated_runs,
+        )
+    )
+    if format == "text":
+        typer.echo(
+            "\n".join(
+                [
+                    f"dry_run: {result['dry_run']}",
+                    f"shop_id: {result['shop_id']}",
+                    f"restore_point_utc: {result['restore_point_utc']}",
+                    f"benchmarks: {result['benchmarks']}",
+                    f"scenarios: {result['scenarios']}",
+                    f"scenario_runs: {result['scenario_runs']}",
+                ]
+            )
+        )
+        return
+    typer.echo(json.dumps(result, indent=2, default=str))
+
+
 @app.command("scenario-bulk-run")
 def scenario_bulk_run(
     scenario_ids: str = typer.Option(
@@ -2475,7 +2825,7 @@ def product_update(
 
 @app.command("agent-deploy")
 def agent_deploy(
-    agent_ids: list[str] = typer.Argument(..., help="One or more Agent IDs to deploy"),
+    agent_ids: list[str] = AGENT_DEPLOY_AGENT_IDS_ARGUMENT,
     description: str = typer.Option("", "--description", "-d", help="Optional revision description"),
     shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
 ) -> None:
@@ -2580,7 +2930,6 @@ def agent_revision_diff(
     Example:
         applied agent-revision-diff <agent_id> 54 55
     """
-    import difflib
 
     client = get_client(shop_id=shop_id)
 
@@ -2661,7 +3010,7 @@ def agent_revision_diff(
     for field in ("model", "escalation_mode", "use_guardrails", "auto_reply", "response_delay_in_seconds"):
         typer.echo(f"  {field}: {agent.get(field)}")
 
-    typer.echo(f"\n--- PROMPT (guardrail, current) ---")
+    typer.echo("\n--- PROMPT (guardrail, current) ---")
     guardrail = agent.get("guardrail") or ""
     typer.echo(f"  Length: {len(guardrail)} chars")
     typer.echo(f"  First 300 chars:\n{guardrail[:300]}")
@@ -2673,8 +3022,8 @@ def agent_revision_diff(
     for f in active[:20]:
         typer.echo(f"  [{f.get('trigger','?')}] {f.get('name')} ({f.get('status')})")
 
-    typer.echo(f"\nNote: Full prompt diff requires snapshot storage per revision (not yet available in API).")
-    typer.echo(f"To investigate: compare guardrail text above against the known-good version,")
+    typer.echo("\nNote: Full prompt diff requires snapshot storage per revision (not yet available in API).")
+    typer.echo("To investigate: compare guardrail text above against the known-good version,")
     typer.echo(f"and check if any flows were added/removed between {rev_a['created_at'][:10]} and {rev_b['created_at'][:10]}.")