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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.74
+Version: 0.6.0
 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.0/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.0/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.0}/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,19 @@ 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"
+AGENT_DEPLOY_AGENT_IDS_ARGUMENT = typer.Argument(
+    ...,
+    help="One or more Agent IDs to deploy",
+)
 
 
 def _version_callback(value: bool) -> None:
@@ -144,6 +163,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 +290,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 +309,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"))
 
 
 # -----------------------------------------------------------------------------
@@ -2475,7 +2724,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 +2829,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 +2909,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 +2921,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]}.")
 
 

{applied_cli-0.5.74 → applied_cli-0.6.0}/applied_cli/client.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import os
 import uuid
+from collections.abc import AsyncIterator
 from typing import Any
 
 import httpx
@@ -531,6 +532,25 @@ class AppliedClient:
             # Do not let proposal logging mask the access-mode decision.
             return
 
+    async def record_tool_access_mode_decision(
+        self,
+        *,
+        tool_name: str,
+        raw_input: dict[str, Any],
+        read_write_mode: str,
+        status: str,
+    ) -> None:
+        await self._record_access_mode_change(
+            method="POST",
+            path=f"/mcp/tools/{tool_name}/",
+            body={
+                "tool_name": tool_name,
+                "input": raw_input,
+                "read_write_mode": read_write_mode,
+            },
+            status=status,
+        )
+
     async def _fetch_current_object(
         self,
         *,
@@ -707,6 +727,68 @@ class AppliedClient:
                 )
             return result
 
+    async def request(
+        self,
+        method: str,
+        path: str,
+        params: dict[str, Any] | None = None,
+        body: dict[str, Any] | None = None,
+        shop_id: str | None = None,
+    ) -> Any:
+        """Public authenticated request API for catalog tools and integrations."""
+        return await self._request(
+            method,
+            path,
+            params=params,
+            body=body,
+            shop_id=shop_id,
+        )
+
+    async def iter_pages(
+        self,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        page_style: str = "page",
+        shop_id: str | None = None,
+        max_pages: int | None = None,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Yield rows from page- or offset-paginated list endpoints."""
+        base_params = dict(params or {})
+        limit = int(base_params.get("limit") or 100)
+        page = int(base_params.get("page") or 1)
+        offset = int(base_params.get("offset") or 0)
+        pages_seen = 0
+
+        while True:
+            request_params = dict(base_params)
+            if page_style == "offset":
+                request_params["offset"] = offset
+            elif page_style == "page":
+                request_params["page"] = page
+            else:
+                raise ValueError("page_style must be 'page' or 'offset'")
+
+            data = await self.request(
+                "GET",
+                path,
+                params=request_params,
+                shop_id=shop_id,
+            )
+            rows = self._normalize_response(data)
+            for row in rows:
+                yield row
+
+            pages_seen += 1
+            if max_pages is not None and pages_seen >= max_pages:
+                break
+            if not isinstance(data, dict) or not data.get("next"):
+                break
+            if page_style == "offset":
+                offset += limit
+            else:
+                page += 1
+
     async def _upload_request(
         self,
         method: str,