cited-cli 0.3.2__py3-none-any.whl

cited_cli/commands/hq.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cited_cli.output.formatter import OutputContext, print_error, print_result
+from cited_cli.output.tables import render_bar
+from cited_cli.utils.errors import CitedAPIError, ExitCode, handle_api_error
+from cited_core.api import endpoints
+from cited_core.api.client import CitedClient
+from cited_core.auth.store import TokenStore
+from cited_core.config.manager import ConfigManager
+
+hq_app = typer.Typer(name="hq", help="Business HQ dashboard.", invoke_without_command=True)
+
+
+def _get_client(ctx: typer.Context) -> tuple[OutputContext, CitedClient]:
+    obj = ctx.obj or {}
+    out: OutputContext = obj.get("output", OutputContext())
+    cfg: ConfigManager = obj.get("config", ConfigManager())
+    profile = obj.get("profile", "default")
+    env = cfg.get_environment(profile, obj.get("env_override"))
+    api_url = cfg.get_api_url(profile, obj.get("env_override"))
+
+    store = TokenStore()
+    token = store.get_token(env)
+    if not token:
+        print_error(f"Not logged in to {env}. Run: cited login", out)
+        raise typer.Exit(ExitCode.AUTH_ERROR)
+
+    return out, CitedClient(base_url=api_url, token=token)
+
+
+@hq_app.callback(invoke_without_command=True)
+def hq_dashboard(
+    ctx: typer.Context,
+    business_id: Annotated[str, typer.Argument(help="Business ID")],
+    full: Annotated[bool, typer.Option("--full", help="Include all data (heavy)")] = False,
+    personas: Annotated[bool, typer.Option("--personas", help="Include personas")] = False,
+    products: Annotated[bool, typer.Option("--products", help="Include products")] = False,
+    intents: Annotated[bool, typer.Option("--intents", help="Include buyer intents")] = False,
+    actions: Annotated[bool, typer.Option("--actions", help="Include priority actions")] = False,
+) -> None:
+    """Show the Business HQ dashboard."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    out, client = _get_client(ctx)
+    try:
+        # Fetch base HQ data
+        if full:
+            path = endpoints.HQ_HEAVY.format(business_id=business_id)
+        else:
+            path = endpoints.HQ.format(business_id=business_id)
+        data = client.get(path)
+
+        # Fetch additional sections if requested
+        if personas and not full:
+            data["personas"] = client.get(endpoints.PERSONAS.format(business_id=business_id))
+        if products and not full:
+            data["products"] = client.get(endpoints.PRODUCTS.format(business_id=business_id))
+        if intents and not full:
+            path = endpoints.BUYER_INTENTS.format(business_id=business_id)
+            data["buyer_intents"] = client.get(path)
+        if actions and not full:
+            path = endpoints.HQ_PRIORITY.format(business_id=business_id)
+            data["priority_actions"] = client.get(path)
+
+        def _human(d: object, console: Console) -> None:
+            if not isinstance(d, dict):
+                return
+            name = d.get("business", {}).get("name", d.get("name", "Business HQ"))
+            console.print()
+            console.rule(f"[bold]{name}[/bold]")
+
+            # Health scores
+            scores = d.get("health_scores", d.get("scores", {}))
+            if scores:
+                console.print("\n[bold]Health Scores[/bold]")
+                if isinstance(scores, dict):
+                    for label, val in scores.items():
+                        if isinstance(val, (int, float)):
+                            render_bar(label.replace("_", " ").title(), val, console=console)
+
+            # Personas
+            if d.get("personas"):
+                console.print("\n[bold]Personas[/bold]")
+                p_list = (
+                    d["personas"] if isinstance(d["personas"], list)
+                    else d["personas"].get("items", [])
+                )
+                for p in p_list:
+                    console.print(f"  - {p.get('name', 'Unknown')}")
+
+            # Products
+            if d.get("products"):
+                console.print("\n[bold]Products[/bold]")
+                prod_list = (
+                    d["products"] if isinstance(d["products"], list)
+                    else d["products"].get("items", [])
+                )
+                for p in prod_list:
+                    console.print(f"  - {p.get('name', 'Unknown')}")
+
+            # Priority actions
+            if d.get("priority_actions"):
+                console.print("\n[bold]Priority Actions[/bold]")
+                pa = d["priority_actions"]
+                act_list = (
+                    pa if isinstance(pa, list)
+                    else pa.get("items", [])
+                )
+                for a in act_list:
+                    label = a.get('title', a.get('description', ''))
+                    console.print(f"  [{a.get('priority', '?')}] {label}")
+
+            console.print()
+
+        print_result(data, out, human_formatter=_human)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()

cited_cli/commands/job.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from cited_cli.output.formatter import OutputContext, print_error, print_result, print_success
+from cited_cli.output.progress import watch_job
+from cited_cli.output.tables import render_kv
+from cited_cli.utils.errors import CitedAPIError, ExitCode, handle_api_error
+from cited_cli.utils.interactive import confirm_action
+from cited_core.api.client import CitedClient
+from cited_core.auth.store import TokenStore
+from cited_core.config.manager import ConfigManager
+
+job_app = typer.Typer(name="job", help="Monitor and manage background jobs.")
+
+
+def _get_client(ctx: typer.Context) -> tuple[OutputContext, CitedClient]:
+    obj = ctx.obj or {}
+    out: OutputContext = obj.get("output", OutputContext())
+    cfg: ConfigManager = obj.get("config", ConfigManager())
+    profile = obj.get("profile", "default")
+    env = cfg.get_environment(profile, obj.get("env_override"))
+    api_url = cfg.get_api_url(profile, obj.get("env_override"))
+
+    store = TokenStore()
+    token = store.get_token(env)
+    if not token:
+        print_error(f"Not logged in to {env}. Run: cited login", out)
+        raise typer.Exit(ExitCode.AUTH_ERROR)
+
+    return out, CitedClient(base_url=api_url, token=token)
+
+
+def _guess_job_type(job_id: str, client: CitedClient) -> str:
+    """Try to determine job type by probing status endpoints."""
+    for prefix in ["/audit", "/recommendations", "/solutions"]:
+        try:
+            client.get(f"{prefix}/{job_id}/status")
+            return prefix.strip("/")
+        except CitedAPIError:
+            continue
+    return "audit"  # default fallback
+
+
+@job_app.command("watch")
+def job_watch(
+    ctx: typer.Context,
+    job_id: Annotated[str, typer.Argument(help="Job ID to watch")],
+    job_type: Annotated[
+        str,
+        typer.Option("--type", "-t", help="Job type: audit, recommendations, solutions"),
+    ] = "",
+    interval: Annotated[
+        float,
+        typer.Option("--interval", "-i", help="Poll interval in seconds"),
+    ] = 2.0,
+) -> None:
+    """Watch a job's progress until completion."""
+    out, client = _get_client(ctx)
+    try:
+        if not job_type:
+            job_type = _guess_job_type(job_id, client)
+
+        status_path = f"/{job_type}/{job_id}/status"
+        result = watch_job(client, status_path, out.console, poll_interval=interval)
+
+        status = result.get("status", "unknown")
+        if status in ("completed", "complete", "done"):
+            print_success(f"Job {job_id[:8]} completed", out)
+        elif status in ("failed", "error"):
+            print_error(f"Job {job_id[:8]} failed: {result.get('error', '')}", out)
+            raise typer.Exit(ExitCode.ERROR)
+        else:
+            print_result(result, out, human_formatter=lambda d, c: render_kv("Job Result", d, c))
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@job_app.command("cancel")
+def job_cancel(
+    ctx: typer.Context,
+    job_id: Annotated[str, typer.Argument(help="Job ID to cancel")],
+    job_type: Annotated[
+        str,
+        typer.Option("--type", "-t", help="Job type: audit, recommendations, solutions"),
+    ] = "",
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation")] = False,
+) -> None:
+    """Cancel a running job."""
+    out, client = _get_client(ctx)
+    confirm_action(f"Cancel job {job_id[:8]}?", out, skip=yes)
+    try:
+        if not job_type:
+            job_type = _guess_job_type(job_id, client)
+
+        cancel_path = f"/{job_type}/{job_id}/cancel"
+        client.post(cancel_path)
+        print_success(f"Cancelled job {job_id[:8]}", out)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()

cited_cli/commands/mcp_cmd.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import Annotated
+
+import typer
+
+mcp_app = typer.Typer(help="MCP server for AI agent integration.", no_args_is_help=True)
+
+
+@mcp_app.command("serve")
+def mcp_serve(
+    env: Annotated[
+        str | None,
+        typer.Option("--env", "-e", help="Target environment (dev, prod, local)"),
+    ] = None,
+) -> None:
+    """Start the MCP server (stdio transport) for AI agent tool calls."""
+    try:
+        from cited_mcp.server import run_server
+    except ImportError:
+        print(
+            'MCP dependencies not installed. Run: pip install "cited-cli[mcp]"',
+            file=sys.stderr,
+        )
+        raise typer.Exit(1)  # noqa: B904
+    if env:
+        os.environ["CITED_ENV"] = env
+    run_server()

cited_cli/commands/named_audit.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cited_cli.output.formatter import OutputContext, print_error, print_result, print_success
+from cited_cli.output.tables import render_kv, render_table
+from cited_cli.utils.errors import CitedAPIError, ExitCode, handle_api_error
+from cited_cli.utils.interactive import can_prompt, prompt_if_missing
+from cited_core.api import endpoints
+from cited_core.api.client import CitedClient
+from cited_core.auth.store import TokenStore
+from cited_core.config.manager import ConfigManager
+
+named_audit_app = typer.Typer(name="template", help="Manage audit templates.")
+
+
+def _get_client(ctx: typer.Context) -> tuple[OutputContext, CitedClient]:
+    obj = ctx.obj or {}
+    out: OutputContext = obj.get("output", OutputContext())
+    cfg: ConfigManager = obj.get("config", ConfigManager())
+    profile = obj.get("profile", "default")
+    env = cfg.get_environment(profile, obj.get("env_override"))
+    api_url = cfg.get_api_url(profile, obj.get("env_override"))
+
+    store = TokenStore()
+    token = store.get_token(env)
+    if not token:
+        print_error(f"Not logged in to {env}. Run: cited login", out)
+        raise typer.Exit(ExitCode.AUTH_ERROR)
+
+    return out, CitedClient(base_url=api_url, token=token)
+
+
+@named_audit_app.command("list")
+def template_list(
+    ctx: typer.Context,
+    business_id: Annotated[
+        str | None,
+        typer.Option("--business", "-b", help="Filter by business ID"),
+    ] = None,
+) -> None:
+    """List audit templates."""
+    out, client = _get_client(ctx)
+    try:
+        params = {}
+        if business_id:
+            params["business_id"] = business_id
+        data = client.get(endpoints.NAMED_AUDITS, params=params or None)
+        templates = (
+            data if isinstance(data, list)
+            else data.get("named_audits", data.get("items", []))
+        )
+
+        def _human(d: object, console: Console) -> None:
+            items = d if isinstance(d, list) else []
+            rows = []
+            for t in items:
+                questions = t.get("questions", [])
+                rows.append([
+                    t.get("id", "")[:8],
+                    t.get("name", ""),
+                    t.get("business_name", t.get("business_id", "")),
+                    str(len(questions)),
+                    t.get("created_at", "")[:19] if t.get("created_at") else "",
+                ])
+            render_table(
+                "Audit Templates",
+                ["ID", "Name", "Business", "Questions", "Created"],
+                rows,
+                console,
+            )
+
+        print_result(templates, out, human_formatter=_human)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@named_audit_app.command("get")
+def template_get(
+    ctx: typer.Context,
+    named_audit_id: Annotated[str, typer.Argument(help="Audit template ID")],
+) -> None:
+    """Get audit template details."""
+    out, client = _get_client(ctx)
+    try:
+        path = endpoints.NAMED_AUDIT.format(named_audit_id=named_audit_id)
+        data = client.get(path)
+
+        def _human(d: object, console: Console) -> None:
+            if not isinstance(d, dict):
+                console.print(d)
+                return
+            questions = d.pop("questions", [])
+            render_kv("Audit Template", d, console)
+            if questions:
+                console.print("\n[bold]Questions:[/bold]")
+                for i, q in enumerate(questions, 1):
+                    text = q.get("question", q) if isinstance(q, dict) else q
+                    console.print(f"  {i}. {text}")
+
+        print_result(data, out, human_formatter=_human)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@named_audit_app.command("create")
+def template_create(
+    ctx: typer.Context,
+    name: Annotated[str | None, typer.Option("--name", "-n", help="Template name")] = None,
+    business_id: Annotated[str | None, typer.Option("--business", "-b", help="Business ID")] = None,
+    description: Annotated[
+        str | None, typer.Option("--description", "-d", help="Template description")
+    ] = None,
+    questions: Annotated[
+        list[str] | None,
+        typer.Option("--question", "-q", help="Question to include (repeatable)"),
+    ] = None,
+) -> None:
+    """Create a new audit template."""
+    out, client = _get_client(ctx)
+    name = prompt_if_missing(name, "--name", "Template name", out)
+    business_id = prompt_if_missing(business_id, "--business", "Business ID", out)
+    if not questions and can_prompt(out):
+        out.console.print("\n[bold]Enter questions (one per line, empty line to finish):[/bold]")
+        entered: list[str] = []
+        while True:
+            q = typer.prompt(f"  Q{len(entered) + 1}", default="")
+            if not q:
+                break
+            entered.append(q)
+        if entered:
+            questions = entered
+    try:
+        payload: dict[str, object] = {
+            "name": name,
+            "business_id": business_id,
+        }
+        if description:
+            payload["description"] = description
+        if questions:
+            payload["questions"] = [{"question": q} for q in questions]
+
+        data = client.post(endpoints.NAMED_AUDITS, json=payload)
+        template_id = data.get("id", "")
+        print_result(data, out, human_formatter=lambda d, c: render_kv("Template Created", d, c))
+        if not out.json_mode and template_id:
+            out.console.print(
+                f"\nTemplate ID: [bold]{template_id}[/bold]"
+                f"\nRun audit:   [bold]cited audit start {template_id}"
+                f" --business {business_id}[/bold]"
+            )
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@named_audit_app.command("update")
+def template_update(
+    ctx: typer.Context,
+    named_audit_id: Annotated[str, typer.Argument(help="Audit template ID to update")],
+    name: Annotated[
+        str | None, typer.Option("--name", "-n", help="New template name")
+    ] = None,
+    description: Annotated[
+        str | None, typer.Option("--description", "-d", help="New description")
+    ] = None,
+    questions: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--question", "-q",
+            help="Replacement question (repeatable — replaces all existing)",
+        ),
+    ] = None,
+) -> None:
+    """Update an audit template's name, description, or questions.
+
+    When --question flags are provided, they replace ALL existing questions.
+    Omit --question to keep existing questions unchanged.
+    """
+    out, client = _get_client(ctx)
+    try:
+        payload: dict[str, object] = {}
+        if name is not None:
+            payload["name"] = name
+        if description is not None:
+            payload["description"] = description
+        if questions is not None:
+            payload["questions"] = [{"question": q} for q in questions]
+
+        if not payload:
+            print_error("Nothing to update. Provide --name, --description, or --question.", out)
+            raise typer.Exit(ExitCode.VALIDATION_ERROR)
+
+        path = endpoints.NAMED_AUDIT.format(named_audit_id=named_audit_id)
+        data = client.put(path, json=payload)
+
+        def _human(d: object, console: Console) -> None:
+            if not isinstance(d, dict):
+                console.print(d)
+                return
+            questions_list = d.pop("questions", [])
+            render_kv("Template Updated", d, console)
+            if questions_list:
+                console.print("\n[bold]Questions:[/bold]")
+                for i, q in enumerate(questions_list, 1):
+                    text = q.get("question", q) if isinstance(q, dict) else q
+                    console.print(f"  {i}. {text}")
+
+        print_result(data, out, human_formatter=_human)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()
+
+
+@named_audit_app.command("delete")
+def template_delete(
+    ctx: typer.Context,
+    named_audit_id: Annotated[str, typer.Argument(help="Audit template ID to delete")],
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation")] = False,
+) -> None:
+    """Delete an audit template."""
+    out, client = _get_client(ctx)
+    try:
+        if not yes:
+            confirmed = typer.confirm(f"Delete template {named_audit_id}?")
+            if not confirmed:
+                raise typer.Abort()
+
+        path = endpoints.NAMED_AUDIT.format(named_audit_id=named_audit_id)
+        client.delete(path)
+        print_success(f"Template {named_audit_id} deleted.", out)
+    except CitedAPIError as e:
+        handle_api_error(e, out.json_mode)
+    finally:
+        client.close()