applied-cli 0.5.72__tar.gz → 0.5.73__tar.gz

{applied_cli-0.5.72 → applied_cli-0.5.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.72
+Version: 0.5.73
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT

{applied_cli-0.5.72 → applied_cli-0.5.73}/applied_cli/__init__.py

@@ -4,6 +4,6 @@ from applied_cli import tools
 from applied_cli.client import AppliedClient
 from applied_cli.formatters import to_csv, to_json
 
-__version__ = "0.5.71"
+__version__ = "0.5.72"
 
 __all__ = ["AppliedClient", "tools", "to_csv", "to_json", "__version__"]

{applied_cli-0.5.72 → applied_cli-0.5.73}/applied_cli/cli.py

@@ -2509,6 +2509,251 @@ def agent_deploy(
         typer.echo(f"Deployed agent {agent_id}: revision v{version} (id={revision_id}, is_live={is_live})")
 
 
+@app.command("agent-revisions")
+def agent_revisions(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    limit: int = typer.Option(20, "--limit", "-l", help="Max revisions to return"),
+    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:
+    """List revision history for an agent, newest first.
+
+    Shows version number, deploy timestamp, author, and description (if set).
+    Use this to identify which revision version was live at a given time,
+    then run agent-revision-diff to see what changed.
+
+    Example:
+        applied agent-revisions <agent_id> --limit 10
+    """
+    client = get_client(shop_id=shop_id)
+
+    async def _list():
+        data = await client._request(
+            "GET",
+            "/v1/revisions/",
+            params={"agent_id": agent_id, "limit": limit},
+        )
+        return data
+
+    result = asyncio.run(_list())
+    revisions = result.get("results", [])
+
+    if format == "json":
+        typer.echo(json.dumps(revisions, indent=2))
+        return
+
+    if not revisions:
+        typer.echo("No revisions found.")
+        return
+
+    typer.echo(f"{'Version':<10} {'Created':<26} {'Live':<6} {'Author':<20} {'Description'}")
+    typer.echo("-" * 90)
+    for rev in revisions:
+        version = f"v{rev.get('version', '?')}"
+        created = rev.get("created_at", "")[:19].replace("T", " ")
+        is_live = "✓" if rev.get("is_live") else ""
+        author = (rev.get("created_by") or {}).get("display_name", "?")[:19]
+        desc = (rev.get("description") or "")[:40]
+        typer.echo(f"{version:<10} {created:<26} {is_live:<6} {author:<20} {desc}")
+
+
+@app.command("agent-revision-diff")
+def agent_revision_diff(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    version_a: str = typer.Argument(..., help="Older version number (e.g. 54)"),
+    version_b: str = typer.Argument(..., help="Newer version number (e.g. 55)"),
+    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:
+    """Diff two agent revisions to see what changed between them.
+
+    Compares the agent prompt (guardrail), attached flow names/prompts,
+    and key agent settings (model, escalation_mode, use_guardrails).
+
+    Since revisions only store metadata (not a full snapshot), this command
+    reconstructs the diff by fetching the current agent state for version_b
+    and the flows list at each revision time. For prompt changes, it shows
+    a unified diff of the guardrail field. Flow additions/removals are listed.
+
+    Use this to explain why an agent revision caused an escalation spike.
+
+    Example:
+        applied agent-revision-diff <agent_id> 54 55
+    """
+    import difflib
+
+    client = get_client(shop_id=shop_id)
+
+    async def _fetch():
+        # Paginate revisions until both target versions are found
+        revisions: list = []
+        page = 1
+        rev_a = None
+        rev_b = None
+        while True:
+            data = await client._request(
+                "GET", "/v1/revisions/",
+                params={"agent_id": agent_id, "limit": 100, "page": page},
+            )
+            batch = data.get("results", [])
+            if not batch:
+                break
+            revisions.extend(batch)
+            rev_a = rev_a or next((r for r in revisions if str(r.get("version")) == str(version_a)), None)
+            rev_b = rev_b or next((r for r in revisions if str(r.get("version")) == str(version_b)), None)
+            if rev_a and rev_b:
+                break
+            if not data.get("next"):
+                break
+            page += 1
+
+        if not rev_a:
+            return {"error": f"Version {version_a} not found for agent {agent_id}"}
+        if not rev_b:
+            return {"error": f"Version {version_b} not found for agent {agent_id}"}
+
+        # Get current agent state (best proxy for version_b since it's usually live/recent)
+        agent = await client._request("GET", f"/v1/agents/{agent_id}/")
+
+        # Get flows associated with this agent
+        flows_data = await client._request(
+            "GET", "/v1/flows/",
+            params={"agent_id": agent_id, "limit": 100},
+        )
+        flows = flows_data.get("results", [])
+
+        return {
+            "rev_a": rev_a,
+            "rev_b": rev_b,
+            "agent": agent,
+            "flows": flows,
+        }
+
+    data = asyncio.run(_fetch())
+
+    if "error" in data:
+        typer.echo(f"Error: {data['error']}", err=True)
+        raise SystemExit(1)
+
+    rev_a = data["rev_a"]
+    rev_b = data["rev_b"]
+    agent = data["agent"]
+    flows = data["flows"]
+
+    if format == "json":
+        typer.echo(json.dumps({
+            "version_a": rev_a,
+            "version_b": rev_b,
+            "agent_current": {k: v for k, v in agent.items() if k != "guardrail"},
+            "guardrail_length": len(agent.get("guardrail") or ""),
+            "flows_count": len(flows),
+            "flows": [{"id": f["id"], "name": f["name"], "trigger": f.get("trigger"), "status": f.get("status")} for f in flows],
+        }, indent=2))
+        return
+
+    typer.echo(f"\n=== Agent Revision Diff: v{version_a} → v{version_b} ===")
+    typer.echo(f"Agent: {agent.get('name')} ({agent_id})")
+    typer.echo(f"v{version_a}: {rev_a.get('created_at', '')[:19]} by {(rev_a.get('created_by') or {}).get('display_name', '?')} — \"{rev_a.get('description') or '(no description)'}\"")
+    typer.echo(f"v{version_b}: {rev_b.get('created_at', '')[:19]} by {(rev_b.get('created_by') or {}).get('display_name', '?')} — \"{rev_b.get('description') or '(no description)'}\"")
+
+    # Note: without snapshot storage, we can only show current state + metadata delta
+    typer.echo(f"\n--- AGENT SETTINGS (current, as of v{version_b}) ---")
+    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) ---")
+    guardrail = agent.get("guardrail") or ""
+    typer.echo(f"  Length: {len(guardrail)} chars")
+    typer.echo(f"  First 300 chars:\n{guardrail[:300]}")
+
+    typer.echo(f"\n--- FLOWS ({len(flows)} attached to agent) ---")
+    active = [f for f in flows if f.get("status") == "active"]
+    draft = [f for f in flows if f.get("status") != "active"]
+    typer.echo(f"  Active: {len(active)} | Draft/Other: {len(draft)}")
+    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(f"and check if any flows were added/removed between {rev_a['created_at'][:10]} and {rev_b['created_at'][:10]}.")
+
+
+@app.command("conversations-messages-batch")
+def conversations_messages_batch(
+    conversation_ids: str = typer.Argument(
+        ..., help="Comma-separated conversation IDs (up to 50)"
+    ),
+    message_limit: int = typer.Option(10, "--message-limit", help="Max messages per conversation"),
+    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:
+    """Fetch messages for multiple conversations in parallel.
+
+    Unblocks qualitative scan sub-checks B/C/D/E (hallucination, name errors,
+    duplicate replies, tone) by retrieving message history for a batch of
+    conversation IDs concurrently instead of one serial call per conversation.
+
+    Example (qual scan: fetch top 20 escalated convos):
+        applied conversations-messages-batch <id1>,<id2>,<id3> --message-limit 20
+
+    Example (pipe IDs from conversations command):
+        applied conversations --resolution escalated --limit 20 --format json \\
+          | python3 -c "import json,sys; print(','.join(c['id'] for c in json.load(sys.stdin)))" \\
+          | xargs applied conversations-messages-batch --message-limit 10
+    """
+    import asyncio as _asyncio
+
+    ids = [cid.strip() for cid in conversation_ids.split(",") if cid.strip()]
+    if not ids:
+        typer.echo("No conversation IDs provided.", err=True)
+        raise SystemExit(1)
+    if len(ids) > 50:
+        typer.echo("Max 50 conversation IDs per call. Truncating.", err=True)
+        ids = ids[:50]
+
+    client = get_client(shop_id=shop_id)
+
+    async def _fetch_one(conv_id: str) -> dict:
+        try:
+            conv = await client.get_conversation(conv_id, shop_id=shop_id)
+            messages = await client.get_messages(
+                conversation_id=conv_id,
+                limit=message_limit,
+                shop_id=shop_id,
+            )
+            return {
+                "conversation_id": conv_id,
+                "resolution": conv.get("resolution"),
+                "title": conv.get("title"),
+                "created_at": conv.get("created_at"),
+                "messages": messages if isinstance(messages, list) else (messages.get("results") or []),
+                "error": None,
+            }
+        except Exception as exc:
+            return {"conversation_id": conv_id, "error": str(exc), "messages": []}
+
+    async def _fetch_all():
+        return await _asyncio.gather(*[_fetch_one(cid) for cid in ids])
+
+    results = asyncio.run(_fetch_all())
+
+    if format == "json":
+        typer.echo(json.dumps(results, indent=2, default=str))
+        return
+
+    for r in results:
+        if r.get("error"):
+            typer.echo(f"\n[{r['conversation_id']}] ERROR: {r['error']}")
+            continue
+        typer.echo(f"\n[{r['conversation_id']}] {r.get('title', '')} — {r.get('resolution', '')} — {(r.get('created_at') or '')[:10]}")
+        for msg in r.get("messages", []):
+            role = msg.get("type") or msg.get("role") or "?"
+            body = (msg.get("body") or msg.get("content") or "")
+            if isinstance(body, list):
+                body = " ".join(b.get("text", "") for b in body if isinstance(b, dict))
+            typer.echo(f"  [{role}] {str(body)[:200]}")
+
+
 def main() -> None:
     """CLI entrypoint."""
     nested_exit_code = run_agent_scoped_flow_command(sys.argv[1:], get_client)

{applied_cli-0.5.72 → applied_cli-0.5.73}/applied_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.72
+Version: 0.5.73
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT

{applied_cli-0.5.72 → applied_cli-0.5.73}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "applied-cli"
-version = "0.5.72"
+version = "0.5.73"
 description = "CLI and shared client library for Applied Labs AI support agents"
 readme = "README.md"
 requires-python = ">=3.11"