claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/cli/commands/shortcuts.py

@@ -0,0 +1,285 @@
+"""Top-level shortcut commands for common operations.
+
+These are registered at the root level of the CLI for quick access:
+    reflexio publish    (alias for interactions publish)
+    reflexio search     (unified search across all types)
+    reflexio context    (fetch formatted context for agent injection)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from reflexio.cli.errors import handle_errors
+from reflexio.cli.output import (
+    print_info,
+    render,
+)
+from reflexio.cli.state import (
+    get_client,
+    require_agent_version,
+    require_user_id,
+)
+
+
+def _build_publish_args(
+    *,
+    user_id: str | None,
+    session_id: str | None,
+    source: str,
+    agent_version: str | None,
+    wait: bool,
+    user_message: str | None,
+    agent_response: str | None,
+    data: str | None,
+    file: Path | None,
+    stdin: bool,
+    skip_aggregation: bool,
+    force_extraction: bool,
+) -> list[str]:
+    """Assemble the argv the ``interactions publish`` command expects.
+
+    The shortcut ``reflexio publish`` re-invokes the full interactions
+    Typer app rather than duplicating its logic; this helper keeps the
+    shortcut's cyclomatic complexity under ruff's C901 limit by hiding
+    the long chain of ``if`` guards behind a single call.
+
+    Args:
+        user_id: Optional user identifier.
+        session_id: Optional session identifier.
+        source: Source tag recorded on the interaction.
+        agent_version: Optional agent version tag.
+        wait: When True, wait for processing to complete.
+        user_message: Single-turn user message shortcut.
+        agent_response: Single-turn agent response shortcut.
+        data: Inline JSON or ``@filepath`` reference.
+        file: Path to a JSON/JSONL payload file.
+        stdin: When True, read JSON payload from stdin.
+        skip_aggregation: When True, skip post-extract aggregation.
+        force_extraction: When True, bypass all extraction gates
+            (stride_size, cheap pre-filter, LLM should_run).
+
+    Returns:
+        list[str]: argv list ready to hand to ``interactions_app(...)``.
+    """
+    args: list[str] = ["publish"]
+    if user_id:
+        args.extend(["--user-id", user_id])
+    if session_id:
+        args.extend(["--session-id", session_id])
+    args.extend(["--source", source])
+    if agent_version:
+        args.extend(["--agent-version", agent_version])
+    if wait:
+        args.append("--wait")
+    if user_message:
+        args.extend(["--user-message", user_message])
+    if agent_response:
+        args.extend(["--agent-response", agent_response])
+    if data:
+        args.extend(["--data", data])
+    if file:
+        args.extend(["--file", str(file)])
+    if stdin:
+        args.append("--stdin")
+    if skip_aggregation:
+        args.append("--skip-aggregation")
+    if force_extraction:
+        args.append("--force-extraction")
+    return args
+
+
+def register_shortcuts(app: typer.Typer) -> None:
+    """Register shortcut commands on the root Typer app.
+
+    Args:
+        app: The root Typer application
+    """
+
+    @app.command()
+    @handle_errors
+    def publish(
+        ctx: typer.Context,
+        user_id: Annotated[
+            str | None,
+            typer.Option("--user-id", help="User identifier (optional if in payload)"),
+        ] = None,
+        session_id: Annotated[
+            str | None, typer.Option("--session-id", help="Session ID")
+        ] = None,
+        source: Annotated[str, typer.Option(help="Source tag")] = "cli",
+        agent_version: Annotated[
+            str | None, typer.Option("--agent-version", help="Agent version")
+        ] = None,
+        wait: Annotated[
+            bool, typer.Option("--wait", help="Wait for processing to complete")
+        ] = False,
+        user_message: Annotated[
+            str | None, typer.Option("--user-message", help="Single-turn user message")
+        ] = None,
+        agent_response: Annotated[
+            str | None,
+            typer.Option("--agent-response", help="Single-turn agent response"),
+        ] = None,
+        data: Annotated[
+            str | None, typer.Option("--data", help="JSON data or @filepath")
+        ] = None,
+        file: Annotated[
+            Path | None, typer.Option("--file", help="Path to JSON/JSONL file")
+        ] = None,
+        stdin: Annotated[
+            bool, typer.Option("--stdin", help="Read JSON from stdin")
+        ] = False,
+        skip_aggregation: Annotated[
+            bool,
+            typer.Option(
+                "--skip-aggregation",
+                help="Extract profiles/playbooks but skip aggregation",
+            ),
+        ] = False,
+        force_extraction: Annotated[
+            bool,
+            typer.Option(
+                "--force-extraction",
+                help="Bypass all extraction gates (stride_size, cheap pre-filter, LLM should_run) and always run extractors",
+            ),
+        ] = False,
+    ) -> None:
+        """Publish interactions (shortcut for: interactions publish)."""
+        from reflexio.cli.commands.interactions import app as interactions_app
+
+        args = _build_publish_args(
+            user_id=user_id,
+            session_id=session_id,
+            source=source,
+            agent_version=agent_version,
+            wait=wait,
+            user_message=user_message,
+            agent_response=agent_response,
+            data=data,
+            file=file,
+            stdin=stdin,
+            skip_aggregation=skip_aggregation,
+            force_extraction=force_extraction,
+        )
+
+        # Propagate context
+        interactions_app(args, standalone_mode=False, obj=ctx.obj)
+
+    @app.command()
+    @handle_errors
+    def search(
+        ctx: typer.Context,
+        query: Annotated[str, typer.Argument(help="Search query text")],
+        top_k: Annotated[int, typer.Option("--top-k", help="Max results per type")] = 5,
+        threshold: Annotated[float, typer.Option(help="Similarity threshold")] = 0.4,
+        user_id: Annotated[
+            str | None, typer.Option("--user-id", help="Filter by user ID")
+        ] = None,
+        agent_version: Annotated[
+            str | None, typer.Option("--agent-version", help="Filter by agent version")
+        ] = None,
+    ) -> None:
+        """Unified semantic search across profiles and playbooks."""
+        client = get_client(ctx)
+        json_mode = ctx.obj.json_mode
+
+        response = client.search(
+            query=query,
+            top_k=top_k,
+            threshold=threshold,
+            user_id=user_id,
+            agent_version=agent_version,
+        )
+
+        if json_mode:
+            render(response, json_mode=True)
+        else:
+            from reflexio.cli.output import format_context
+
+            context = format_context(
+                profiles=response.profiles,
+                agent_playbooks=response.agent_playbooks,
+                user_playbooks=response.user_playbooks,
+            )
+            if context:
+                print(context)
+
+            total = (
+                len(response.profiles)
+                + len(response.agent_playbooks)
+                + len(response.user_playbooks)
+            )
+            print_info(
+                f"Found {len(response.profiles)} profiles, "
+                f"{len(response.agent_playbooks)} agent playbooks, "
+                f"{len(response.user_playbooks)} user playbooks ({total} total)"
+            )
+
+    @app.command()
+    @handle_errors
+    def context(
+        ctx: typer.Context,
+        user_id: Annotated[
+            str | None, typer.Option("--user-id", help="User ID for profile lookup")
+        ] = None,
+        agent_version: Annotated[
+            str | None,
+            typer.Option(
+                "--agent-version", help="Agent version for playbook filtering"
+            ),
+        ] = None,
+        query: Annotated[
+            str, typer.Option(help="Search query")
+        ] = "general preferences",
+    ) -> None:
+        """Fetch formatted context for agent bootstrap injection."""
+        from reflexio.cli.output import format_context
+
+        client = get_client(ctx)
+        json_mode = ctx.obj.json_mode
+        # The context shortcut scopes profiles to a specific user and
+        # playbooks to a specific agent_version. Silently defaulting
+        # either would produce misleading bootstrap context — fail
+        # loudly instead.
+        resolved_user_id = require_user_id(user_id, command_hint="context bootstrap")
+        resolved_agent_version = require_agent_version(
+            agent_version, command_hint="context bootstrap"
+        )
+
+        profiles = []
+        resp = client.search_user_profiles(
+            user_id=resolved_user_id, query=query, top_k=5
+        )
+        if resp.success:
+            profiles = resp.user_profiles
+
+        agent_playbooks = []
+        resp_pb = client.search_user_playbooks(
+            query=query, agent_version=resolved_agent_version, top_k=5
+        )
+        if resp_pb.success:
+            agent_playbooks = resp_pb.user_playbooks
+
+        if json_mode:
+            render(
+                {
+                    "profiles": [p.model_dump(mode="json") for p in profiles],
+                    "playbooks": [p.model_dump(mode="json") for p in agent_playbooks],
+                },
+                json_mode=True,
+            )
+        else:
+            context_text = format_context(
+                profiles=profiles,
+                agent_playbooks=agent_playbooks,
+            )
+            if context_text:
+                print(context_text)
+
+            print_info(
+                f"Found {len(profiles)} profiles, {len(agent_playbooks)} playbooks"
+            )

package/plugin/vendor/reflexio/reflexio/cli/commands/status_cmd.py

@@ -0,0 +1,143 @@
+"""Server health and status check."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import requests
+import typer
+
+from reflexio.cli.errors import EXIT_NETWORK, CliError, handle_errors, render_error
+from reflexio.cli.output import print_whoami_summary, render
+from reflexio.cli.state import CliState, get_client, resolve_api_key, resolve_url
+
+app = typer.Typer(help="Server health and status.")
+
+
+@app.command()
+@handle_errors
+def check(
+    ctx: typer.Context,
+) -> None:
+    """Check server health status.
+
+    Makes a GET request to the /health endpoint and reports whether
+    the server is reachable and healthy.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+    """
+    state: CliState = ctx.obj
+    json_mode: bool = state.json_mode
+    url = resolve_url(state.server_url)
+    api_key = resolve_api_key(state.api_key)
+
+    headers: dict[str, str] = {}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    try:
+        resp = requests.get(f"{url}/health", headers=headers, timeout=10)
+        resp.raise_for_status()
+    except requests.ConnectionError as exc:
+        err = CliError(
+            error_type="network",
+            message=f"Cannot reach server at {url}",
+            hint="Is the Reflexio server running? Try: reflexio services start",
+            exit_code=EXIT_NETWORK,
+        )
+        render_error(err, json_mode=json_mode)
+        raise SystemExit(1) from exc
+    except requests.HTTPError as exc:
+        if json_mode:
+            envelope = {
+                "ok": False,
+                "error": {"type": "unhealthy", "message": str(exc), "url": url},
+            }
+            print(json.dumps(envelope, indent=2), file=sys.stderr)
+        else:
+            print(
+                f"Error: Server at {url} returned {exc.response.status_code}",
+                file=sys.stderr,
+            )
+        raise SystemExit(1) from exc
+
+    if json_mode:
+        envelope = {"ok": True, "data": {"status": "healthy", "url": url}}
+        print(json.dumps(envelope, indent=2))
+    else:
+        print(f"Connected to {url} (healthy)")
+
+
+@app.command()
+@handle_errors
+def whoami(
+    ctx: typer.Context,
+) -> None:
+    """Show who you are on the server + where your data lands.
+
+    Calls ``GET /api/whoami`` to report the org ID, resolved storage
+    type, and masked storage label for the current API key. Useful
+    for sanity-checking whether you're pointed at the right backend
+    and whether your org has storage configured.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+    """
+    state: CliState = ctx.obj
+    json_mode: bool = state.json_mode
+    client = get_client(ctx)
+
+    try:
+        resp = client.whoami()
+    except requests.HTTPError as exc:
+        if exc.response is not None and exc.response.status_code == 404:
+            # The server is up and reachable — it just doesn't ship the
+            # /api/whoami endpoint yet. Don't tell the user to check
+            # that their server is running; tell them the server may
+            # be on a version that predates this endpoint.
+            err = CliError(
+                error_type="api",
+                message=(
+                    f"{client.base_url}/api/whoami returned 404 — the "
+                    "server is reachable but doesn't expose this endpoint."
+                ),
+                hint=(
+                    "The backend may be running a version that "
+                    "predates '/api/whoami'. Ask the server operator to "
+                    "upgrade, or point REFLEXIO_URL at a deployment "
+                    "that exposes this endpoint."
+                ),
+                exit_code=EXIT_NETWORK,
+            )
+            render_error(err, json_mode=json_mode)
+            raise SystemExit(1) from exc
+        raise  # let handle_errors classify other HTTP errors (401/403/etc.)
+    except requests.ConnectionError as exc:
+        err = CliError(
+            error_type="network",
+            message=f"Failed to reach {client.base_url}/api/whoami: {exc}",
+            hint=(
+                "Check that REFLEXIO_URL points at a running server and "
+                "that REFLEXIO_API_KEY is valid for that backend."
+            ),
+            exit_code=EXIT_NETWORK,
+        )
+        render_error(err, json_mode=json_mode)
+        raise SystemExit(1) from exc
+
+    if json_mode:
+        render(resp, json_mode=True)
+        return
+
+    api_key = resolve_api_key(state.api_key)
+    print_whoami_summary(
+        endpoint=client.base_url,
+        api_key=api_key,
+        org_id=resp.org_id,
+        storage_type=resp.storage_type,
+        storage_label=resp.storage_label,
+        storage_configured=bool(resp.storage_configured),
+        message=resp.message,
+    )