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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.71
+Version: 0.5.73
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT
@@ -53,6 +53,16 @@ applied tickets --status open
 
 # Knowledge base
 applied knowledge --type qa --search "refund"
+applied knowledge <id> --format json
+applied knowledge --source "https://help.example.com" --format csv
+applied knowledge-diff --source "https://help.example.com"
+applied content list --source "https://help.example.com"
+applied content-update <content_id> --text "Corrected source text"
+applied content-resync <content_id> --wait
+applied knowledge-pin <id>
+applied knowledge-link <response_id> --content <content_id>
+applied knowledge-protect <id>
+applied knowledge-unprotect <id>
 
 # Taxonomy
 applied taxonomy --type topics

{applied_cli-0.5.71 → applied_cli-0.5.73}/README.md

@@ -28,6 +28,16 @@ applied tickets --status open
 
 # Knowledge base
 applied knowledge --type qa --search "refund"
+applied knowledge <id> --format json
+applied knowledge --source "https://help.example.com" --format csv
+applied knowledge-diff --source "https://help.example.com"
+applied content list --source "https://help.example.com"
+applied content-update <content_id> --text "Corrected source text"
+applied content-resync <content_id> --wait
+applied knowledge-pin <id>
+applied knowledge-link <response_id> --content <content_id>
+applied knowledge-protect <id>
+applied knowledge-unprotect <id>
 
 # Taxonomy
 applied taxonomy --type topics

{applied_cli-0.5.71 → 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.71 → applied_cli-0.5.73}/applied_cli/cli.py

@@ -22,6 +22,8 @@ app = typer.Typer(
     help="Applied Labs CLI - manage your AI agents and conversations.",
     no_args_is_help=True,
 )
+content_app = typer.Typer(help="Inspect synced content items.")
+app.add_typer(content_app, name="content")
 
 DEFAULT_BASE_URL = "https://api.appliedlabs.ai"
 DEFAULT_CLIENT_URL = "https://appliedlabs.ai"
@@ -938,27 +940,174 @@ def ticket_update(
 
 @app.command()
 def knowledge(
+    id: str = typer.Argument(None, help="Knowledge item ID to fetch"),
     type: str = typer.Option(
         None, "--type", "-t", help="Filter by type: qa, context, escalate, exact"
     ),
     search: str = typer.Option(None, "--search", "-s", help="Search query"),
+    linked_to: str = typer.Option(
+        None, "--linked-to", help="Filter by linked content ID"
+    ),
+    source: str = typer.Option(
+        None, "--source", help="Filter by linked content source URL/domain"
+    ),
+    has_content: bool | None = typer.Option(
+        None,
+        "--has-content/--no-content",
+        help="Filter content-linked vs standalone manual entries",
+    ),
     limit: int = typer.Option(100, "--limit", "-l", help="Results per page"),
     all_pages: bool = typer.Option(
         True, "--all/--no-all", help="Fetch all pages (default: True)"
     ),
+    full: bool = typer.Option(False, "--full", help="Include full audit fields in CSV"),
     format: str = typer.Option(
         "csv", "--format", "-f", help="Output format: csv or json"
     ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
 ) -> None:
-    """List knowledge base items."""
-    client = get_client()
+    """List knowledge base items or fetch one item by ID."""
+    client = get_client(shop_id=shop_id)
+    if id:
+        item_format = "json" if format == "json" else "text"
+        result = asyncio.run(tools.knowledge_get(client, id, output_format=item_format))
+        typer.echo(result)
+        return
+
     result = asyncio.run(
         tools.knowledge_list(
             client,
             kb_type=type,
             search=search,
+            linked_to=linked_to,
+            source=source,
+            has_content=has_content,
+            limit=limit,
+            fetch_all=all_pages,
+            full=full,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("knowledge-diff")
+def knowledge_diff(
+    source: str = typer.Option(..., "--source", help="Source URL/domain to audit"),
+    limit: int = typer.Option(100, "--limit", "-l", help="Results per API page"),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Diff content-linked knowledge against current source pages."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.knowledge_diff(
+            client,
+            source=source,
+            limit=limit,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
+# -----------------------------------------------------------------------------
+# Content commands
+# -----------------------------------------------------------------------------
+
+
+@content_app.command("list")
+def content_list_cmd(
+    type: str = typer.Option(
+        None, "--type", "-t", help="Filter by type: Article, Product, Document, Site"
+    ),
+    status: str = typer.Option(None, "--status", "-s", help="Filter by status"),
+    search: str = typer.Option(None, "--search", help="Search query"),
+    source: str = typer.Option(None, "--source", help="Filter by source URL/domain"),
+    limit: int = typer.Option(100, "--limit", "-l", help="Results per page"),
+    all_pages: bool = typer.Option(
+        True, "--all/--no-all", help="Fetch all pages (default: True)"
+    ),
+    full: bool = typer.Option(False, "--full", help="Include sync audit fields in CSV"),
+    format: str = typer.Option(
+        "csv", "--format", "-f", help="Output format: csv or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """List content items imported into the knowledge system."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.content_list(
+            client,
+            content_type=type,
+            status=status,
+            search=search,
+            source=source,
             limit=limit,
             fetch_all=all_pages,
+            full=full,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("content-resync")
+def content_resync(
+    id: str = typer.Argument(..., help="Content item ID"),
+    wait: bool = typer.Option(
+        False, "--wait", help="Poll until the content item is no longer syncing"
+    ),
+    poll_interval: float = typer.Option(
+        2.0, "--poll-interval", help="Seconds between --wait polls"
+    ),
+    timeout: float = typer.Option(
+        300.0, "--timeout", help="Maximum seconds to wait for sync completion"
+    ),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Trigger a resync for one content item."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.content_resync(
+            client,
+            id,
+            wait=wait,
+            poll_interval=poll_interval,
+            timeout=timeout,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("content-update")
+def content_update(
+    id: str = typer.Argument(..., help="Content item ID"),
+    text: str = typer.Option(None, "--text", help="Override source text"),
+    title: str = typer.Option(None, "--title", help="Content title"),
+    description: str = typer.Option(None, "--description", help="Content description"),
+    status: str = typer.Option(None, "--status", help="Content status"),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Update a content item before resyncing linked responses."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.content_update(
+            client,
+            id,
+            text=text,
+            title=title,
+            description=description,
+            status=status,
             output_format=format,
         )
     )
@@ -1923,6 +2072,9 @@ def knowledge_create(
     ),
     question: str = typer.Option(..., "--question", "-q", help="Trigger text / question"),
     answer: str = typer.Option(..., "--answer", "-a", help="Response text / answer"),
+    chunk_text: str = typer.Option(
+        None, "--chunk-text", help="Raw retrieval chunk text"
+    ),
     guardrail: str = typer.Option("", "--guardrail", help="Guardrail instructions"),
     active: bool = typer.Option(True, "--active/--inactive", help="Whether the item is active"),
     agent_ids: str = typer.Option(
@@ -1941,6 +2093,7 @@ def knowledge_create(
             kb_type=kb_type,
             question=question,
             answer=answer,
+            chunk_text=chunk_text,
             guardrail=guardrail,
             active=active,
             agent_ids=parsed_agent_ids,
@@ -1963,6 +2116,11 @@ def knowledge_update(
     ),
     label_id: str = typer.Option(None, "--label-id", help="Topic label UUID"),
     flow_id: str = typer.Option(None, "--flow-id", help="Flow UUID to associate with"),
+    pin: bool = typer.Option(
+        False,
+        "--pin",
+        help="Mark the response as manually managed while updating",
+    ),
     shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
 ) -> None:
     """Update a knowledge base item."""
@@ -1982,6 +2140,95 @@ def knowledge_update(
             agent_ids=parsed_agent_ids,
             label_id=label_id,
             flow_id=flow_id,
+            pin=pin,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("knowledge-pin")
+def knowledge_pin(
+    id: str = typer.Argument(..., help="Knowledge item ID"),
+    unpin: bool = typer.Option(False, "--unpin", help="Remove the pin/manual flag"),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Pin a knowledge item so manual edits can survive content resyncs."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.knowledge_pin(
+            client,
+            id,
+            pinned=not unpin,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("knowledge-link")
+def knowledge_link(
+    id: str = typer.Argument(..., help="Knowledge item ID"),
+    content_id: str = typer.Option(
+        ..., "--content", help="Content item ID to link to"
+    ),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Link a knowledge item to a content item so sync can manage it."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.knowledge_link(
+            client,
+            id,
+            content_id=content_id,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("knowledge-protect")
+def knowledge_protect(
+    id: str = typer.Argument(..., help="Knowledge item ID"),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Disable autogeneration on the linked content for a knowledge item."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.knowledge_protect(
+            client,
+            id,
+            protected=True,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
+@app.command("knowledge-unprotect")
+def knowledge_unprotect(
+    id: str = typer.Argument(..., help="Knowledge item ID"),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Re-enable autogeneration on the linked content for a knowledge item."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.knowledge_protect(
+            client,
+            id,
+            protected=False,
+            output_format=format,
         )
     )
     typer.echo(result)
@@ -2226,6 +2473,287 @@ def product_update(
     typer.echo(result)
 
 
+@app.command("agent-deploy")
+def agent_deploy(
+    agent_ids: list[str] = typer.Argument(..., help="One or more Agent IDs to deploy"),
+    description: str = typer.Option("", "--description", "-d", help="Optional revision description"),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+) -> None:
+    """Deploy the current configuration for one or more agents as new live revisions.
+
+    Creates a new revision from each agent's current state and immediately sets it live,
+    so new conversations use the latest changes.
+
+    Pass multiple agent IDs to deploy several agents at once:
+        applied agent-deploy <id1> <id2> <id3> --description "what changed"
+    """
+    client = get_client(shop_id=shop_id)
+
+    async def _deploy_one(agent_id: str):
+        return await client._request(
+            "POST",
+            "/v1/revisions/",
+            body={"agent_id": agent_id, "deploy": True, "description": description},
+        )
+
+    async def _deploy_all():
+        import asyncio as _asyncio
+        return await _asyncio.gather(*[_deploy_one(aid) for aid in agent_ids])
+
+    results = asyncio.run(_deploy_all())
+    for result in results:
+        version = result.get("version", "?")
+        revision_id = result.get("id", "?")
+        is_live = result.get("is_live", False)
+        agent_id = result.get("agent_id", "?")
+        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)