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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.5.71
+Version: 0.5.72
 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.72}/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.72}/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,42 @@ 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})")
+
+
 def main() -> None:
     """CLI entrypoint."""
     nested_exit_code = run_agent_scoped_flow_command(sys.argv[1:], get_client)

{applied_cli-0.5.71 → applied_cli-0.5.72}/applied_cli/client.py

@@ -1152,6 +1152,9 @@ class AppliedClient:
         self,
         kb_type: str | None = None,
         search: str | None = None,
+        content_id: str | None = None,
+        source: str | None = None,
+        has_content: bool | None = None,
         limit: int = 100,
         fetch_all: bool = False,
     ) -> list[dict]:
@@ -1160,6 +1163,9 @@ class AppliedClient:
         Args:
             kb_type: Filter by type
             search: Search query
+            content_id: Filter by linked content ID
+            source: Filter by linked content source URL
+            has_content: Filter to content-linked or standalone items
             limit: Page size (default 100, max per request)
             fetch_all: If True, paginate through all results
         """
@@ -1168,6 +1174,12 @@ class AppliedClient:
             params["type"] = kb_type
         if search:
             params["search"] = search
+        if content_id:
+            params["content_id"] = content_id
+        if source:
+            params["source"] = source
+        if has_content is not None:
+            params["content__isnull"] = str(not has_content).lower()
 
         if not fetch_all:
             data = await self._request("GET", "/v1/responses/", params=params)
@@ -1223,6 +1235,7 @@ class AppliedClient:
         content_type: str | None = None,
         status: str | None = None,
         search: str | None = None,
+        source: str | None = None,
         limit: int = 100,
         fetch_all: bool = False,
     ) -> list[dict]:
@@ -1232,6 +1245,7 @@ class AppliedClient:
             content_type: Filter by type - 'Article', 'Product', 'Document', 'Site'
             status: Filter by status - 'Published', 'Draft', 'Pending'
             search: Search query
+            source: Filter by source URL/domain
             limit: Page size (default 100)
             fetch_all: If True, paginate through all results
         """
@@ -1242,6 +1256,8 @@ class AppliedClient:
             params["status"] = status
         if search:
             params["search"] = search
+        if source:
+            params["source"] = source
 
         if not fetch_all:
             data = await self._request("GET", "/v1/content/", params=params)
@@ -1344,6 +1360,10 @@ class AppliedClient:
             body=kwargs,
         )
 
+    async def resync_content(self, content_id: str) -> dict:
+        """Trigger a resync for a content item."""
+        return await self._request("POST", f"/v1/content/{content_id}/resync/")
+
     async def delete_content(self, content_id: str) -> None:
         """Delete a content item."""
         await self._request("DELETE", f"/v1/content/{content_id}/")
@@ -2382,6 +2402,7 @@ class AppliedClient:
         kb_type: str,
         question: str,
         answer: str,
+        chunk_text: str | None = None,
         guardrail: str = "",
         active: bool = True,
         agent_ids: list[str] | None = None,
@@ -2394,6 +2415,7 @@ class AppliedClient:
             kb_type: Type - 'qa', 'exact', 'escalate', 'context', 'greeting', 'signature'
             question: Trigger text / question
             answer: Response text / answer
+            chunk_text: Raw retrieval chunk text
             guardrail: Optional guardrail instructions
             active: Whether the item is active (default True)
             agent_ids: Optional list of agent UUIDs to assign to
@@ -2406,6 +2428,8 @@ class AppliedClient:
             "answer": answer,
             "active": active,
         }
+        if chunk_text is not None:
+            body["chunk_text"] = chunk_text
         if guardrail:
             body["guardrail"] = guardrail
         if agent_ids:
@@ -2426,6 +2450,16 @@ class AppliedClient:
             "PATCH", f"/v1/responses/{response_id}/", body=kwargs
         )
 
+    async def pin_response(
+        self,
+        response_id: str,
+        pinned: bool = True,
+        *,
+        field: str = "pinned",
+    ) -> dict:
+        """Mark a knowledge base response as pinned/manually managed."""
+        return await self.update_response(response_id, **{field: pinned})
+
     async def delete_response(self, response_id: str) -> None:
         """Delete a knowledge base item."""
         await self._request("DELETE", f"/v1/responses/{response_id}/")