claude-smart 0.2.41 → 0.2.43

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

@@ -0,0 +1,303 @@
+"""Profile management commands (list, search, delete, generate)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from reflexio.cli.errors import (
+    EXIT_VALIDATION,
+    CliError,
+    handle_errors,
+    raise_if_failed,
+)
+from reflexio.cli.output import (
+    pagination_meta,
+    print_info,
+    print_user_profiles,
+    render,
+)
+from reflexio.cli.state import get_client, require_user_id
+
+app = typer.Typer(
+    help=(
+        "Manage user profiles. Profiles are normally derived "
+        "automatically from published interactions (via 'reflexio "
+        "publish' + 'reflexio user-profiles regenerate'), but you "
+        "can also seed them manually with 'reflexio user-profiles add'."
+    ),
+)
+
+
+@app.command(name="list")
+@handle_errors
+def list_profiles(
+    ctx: typer.Context,
+    user_id: Annotated[
+        str | None,
+        typer.Option("--user-id", help="User ID to filter profiles"),
+    ] = None,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", help="Maximum number of profiles to return"),
+    ] = 20,
+    status: Annotated[
+        str | None,
+        typer.Option("--status", help="Status filter (current/pending/archived)"),
+    ] = None,
+) -> None:
+    """List user profiles.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        user_id: Optional user ID filter
+        limit: Maximum number of profiles to return
+        status: Optional status filter (current, pending, archived)
+    """
+    if status and status not in ("current", "pending", "archived"):
+        raise CliError(
+            error_type="validation",
+            message=f"Invalid status: {status}. Must be current, pending, or archived.",
+            exit_code=EXIT_VALIDATION,
+        )
+
+    client = get_client(ctx)
+    if user_id:
+        # Filtered: query a single user via /api/get_profiles
+        resp = client.get_profiles(
+            user_id=user_id,
+            top_k=limit,
+            status_filter=[status] if status else None,
+        )
+    else:
+        # Unfiltered: query every user via /api/get_all_profiles.
+        # We intentionally do NOT fall back to resolve_user_id() here —
+        # "no --user-id" means "all users", not "the default user".
+        resp = client.get_all_profiles(
+            limit=limit,
+            status_filter=status,
+        )
+    profiles = resp.user_profiles or []
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(profiles, json_mode=True, meta=pagination_meta(profiles, limit))
+    else:
+        print_info(f"Found {len(profiles)} profile(s)")
+        if profiles:
+            print_user_profiles(profiles)
+
+
+@app.command()
+@handle_errors
+def search_user_profiles(
+    ctx: typer.Context,
+    query: Annotated[
+        str,
+        typer.Argument(help="Semantic search query for profiles"),
+    ],
+    user_id: Annotated[
+        str | None,
+        typer.Option("--user-id", help="User ID to filter profiles"),
+    ] = None,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", help="Maximum number of results"),
+    ] = 10,
+    threshold: Annotated[
+        float | None,
+        typer.Option("--threshold", help="Similarity threshold"),
+    ] = None,
+) -> None:
+    """Search user profiles by semantic query.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        query: Search query string
+        user_id: Optional user ID filter
+        limit: Maximum number of results
+        threshold: Optional similarity threshold
+    """
+    client = get_client(ctx)
+    # Profile search requires a specific user_id — the server's
+    # SearchUserProfileRequest.user_id is NonEmptyStr (cross-user
+    # profile search is not currently supported). require_user_id
+    # errors out cleanly instead of silently falling back to
+    # DEFAULT_USER_ID.
+    resolved_user_id = require_user_id(user_id, command_hint="profile search")
+
+    kwargs: dict = {
+        "query": query,
+        "user_id": resolved_user_id,
+        "top_k": limit,
+    }
+    if threshold is not None:
+        kwargs["threshold"] = threshold
+
+    resp = client.search_user_profiles(**kwargs)
+    profiles = resp.user_profiles or []
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(profiles, json_mode=True, meta=pagination_meta(profiles, limit))
+    else:
+        print_info(f"Found {len(profiles)} profile(s)")
+        if profiles:
+            print_user_profiles(profiles)
+
+
+@app.command()
+@handle_errors
+def delete(
+    ctx: typer.Context,
+    user_id: Annotated[
+        str,
+        typer.Option("--user-id", help="User ID (required)"),
+    ],
+    profile_id: Annotated[
+        str,
+        typer.Option("--profile-id", help="Specific profile ID to delete"),
+    ] = "",
+) -> None:
+    """Delete a user profile.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        user_id: User ID owning the profile
+        profile_id: Specific profile ID to delete (empty string for all user profiles)
+    """
+    client = get_client(ctx)
+    resp = client.delete_profile(
+        user_id=user_id,
+        profile_id=profile_id,
+        wait_for_response=True,
+    )
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(resp, json_mode=True)
+    else:
+        label = (
+            f"profile {profile_id}" if profile_id else f"profiles for user {user_id}"
+        )
+        print_info(f"Deleted {label}")
+
+
+@app.command(name="delete-all")
+@handle_errors
+def delete_all(
+    ctx: typer.Context,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip confirmation prompt"),
+    ] = False,
+) -> None:
+    """Delete all profiles.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        yes: If True, skip confirmation prompt
+    """
+    if not yes:
+        confirmed = typer.confirm("Are you sure you want to delete all profiles?")
+        if not confirmed:
+            raise typer.Abort()
+
+    client = get_client(ctx)
+    resp = client.delete_all_profiles()
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(resp, json_mode=True)
+    else:
+        print_info("All profiles deleted")
+
+
+@app.command()
+@handle_errors
+def add(
+    ctx: typer.Context,
+    user_id: Annotated[
+        str,
+        typer.Option("--user-id", help="User ID owning the profile"),
+    ],
+    content: Annotated[
+        str,
+        typer.Option("--content", help="Profile content text"),
+    ],
+) -> None:
+    """Manually add a user profile, bypassing interaction-based inference.
+
+    Useful for seeding a known fact about the user (testing, migration,
+    manual fact injection). Most users should rely on automatic profile
+    generation via ``reflexio publish`` + ``reflexio user-profiles
+    regenerate``.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        user_id: User the profile belongs to
+        content: Profile content text (used for embedding)
+    """
+    client = get_client(ctx)
+    resp = client.add_user_profile(
+        [{"user_id": user_id, "content": content, "source": "cli-manual"}]
+    )
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(resp, json_mode=True)
+    else:
+        raise_if_failed(resp, default="Failed to add user profile")
+        print_info(f"User profile added: {content[:80]}")
+
+
+@app.command()
+@handle_errors
+def regenerate(
+    ctx: typer.Context,
+    user_id: Annotated[
+        str,
+        typer.Option("--user-id", help="User ID (required)"),
+    ],
+    wait: Annotated[
+        bool,
+        typer.Option("--wait", help="Wait for profile generation to complete"),
+    ] = False,
+) -> None:
+    """Re-run profile generation for a user.
+
+    Re-runs the inference pipeline over the user's published
+    interactions to refresh their profiles.  Renamed from
+    ``generate`` for consistency with ``agent-playbooks regenerate``.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        user_id: User ID to generate profiles for
+        wait: If True, wait for generation to complete
+    """
+    client = get_client(ctx)
+    resp = client.rerun_profile_generation(
+        user_id=user_id,
+        wait_for_response=wait,
+    )
+
+    # When waiting, auto-promote PENDING profiles to CURRENT so they're
+    # immediately visible in `list` output.  Without this, regenerated
+    # profiles stay in PENDING status and the default list filter (CURRENT
+    # only) returns 0 results.
+    promoted = 0
+    if wait:
+        try:
+            upgrade_resp = client.upgrade_profiles(user_id=user_id)
+            promoted = upgrade_resp.profiles_promoted
+        except Exception:
+            print_info("Warning: promotion failed, but regeneration succeeded")
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(resp, json_mode=True)
+    elif wait:
+        print_info(f"Profile generation complete ({promoted} profile(s) promoted)")
+    else:
+        print_info("Profile generation started")

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

@@ -0,0 +1,289 @@
+"""Service management commands (Typer wrapper around existing run/stop logic)."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from reflexio.cli import run_services as run_mod
+from reflexio.cli import stop_services as stop_mod
+from reflexio.cli.bootstrap_config import _VALID_STORAGE_BACKENDS
+
+_logger = logging.getLogger(__name__)
+
+app = typer.Typer(help="Start and stop Reflexio services.")
+
+
+def _ensure_llm_configured(env_path: Path) -> None:
+    """Run the first-run LLM + embedding wizard when no key is configured.
+
+    Called by ``services start`` before uvicorn boots. Replaces the ugly
+    ``RuntimeError: No LLM API keys found`` traceback that used to crash the
+    FastAPI lifespan handler on a fresh install.
+
+    Behaviour matrix:
+        - At least one LLM key AND an embedding-capable provider in env →
+          return silently, startup continues.
+        - At least one LLM key but no cloud embedder, and ``chromadb`` is
+          importable → log "Using local embedder as fallback" and return;
+          runtime auto-detection (Layer A) will pick ``local/minilm-l6-v2``
+          for the EMBEDDING role. No prompt, no blocking.
+        - No LLM key, interactive TTY → prompt for a provider + key, then
+          (conditionally) prompt for an embedding key, re-load the .env so
+          the new values land in ``os.environ``, and return.
+        - Missing only an embedding key (e.g. user set ANTHROPIC_API_KEY
+          manually) AND chromadb is unavailable → prompt only for an
+          embedding provider.
+        - No LLM key, non-interactive stdin (CI, nohup, container) → print a
+          clean pointer to the .env file and raise ``typer.Exit(1)`` so the
+          user never sees the uvicorn/starlette traceback.
+
+    Args:
+        env_path (Path): Path to the user's ``.env`` file (``~/.reflexio/.env``
+            in the default installation). Keys selected in the wizard are
+            written here.
+
+    Raises:
+        typer.Exit: When stdin is not a TTY and no LLM key is configured.
+    """
+    from dotenv import load_dotenv
+
+    from reflexio.cli.commands.setup_cmd import (
+        _prompt_embedding_provider,
+        _prompt_llm_provider,
+    )
+    from reflexio.server.llm.model_defaults import (
+        EMBEDDING_CAPABLE_PROVIDERS,
+        GENERATION_CAPABLE_PROVIDERS,
+        detect_available_providers,
+    )
+    from reflexio.server.llm.providers.local_embedding_provider import (
+        is_chromadb_importable,
+    )
+
+    providers = detect_available_providers()
+    has_embedding = any(p in EMBEDDING_CAPABLE_PROVIDERS for p in providers)
+    has_generation = any(p in GENERATION_CAPABLE_PROVIDERS for p in providers)
+    embedding_provider = os.environ.get("REFLEXIO_EMBEDDING_PROVIDER", "").lower()
+    if embedding_provider in {"local_service", "internal_service"}:
+        has_embedding = True
+    if providers and has_generation and has_embedding:
+        return
+
+    # Path 3 of the embedding auto-detection: if a generation provider is
+    # configured but no cloud embedder, and chromadb is importable, the
+    # runtime will silently fall back to the local MiniLM embedder (see
+    # ``_auto_detect_model`` in model_defaults.py). No need to prompt or
+    # block startup. We require ``has_generation`` here because providers
+    # like ``["local"]`` (embedder-only) leave the GENERATION role
+    # unresolvable and must still trip the wizard.
+    if has_generation and is_chromadb_importable():
+        _logger.info("Using local embedder as fallback (no cloud embedder configured)")
+        return
+
+    if not sys.stdin.isatty():
+        typer.echo(
+            "\nReflexio is not fully configured yet — "
+            + (
+                "no generation-capable LLM API key"
+                if not has_generation
+                else "no embedding-capable provider"
+            )
+            + f" was found in {env_path}.\n"
+            "Set one of OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, ... "
+            "in that file, or run `reflexio setup init` interactively, "
+            "then retry `reflexio services start`."
+        )
+        raise typer.Exit(1)
+
+    if not has_generation:
+        typer.echo(
+            "\nWelcome to Reflexio! Let's pick an LLM provider before "
+            "starting the local services."
+        )
+        typer.echo(
+            "(If you wanted Managed or Self-hosted Reflexio instead, press "
+            "Ctrl+C and run `reflexio setup init`.)"
+        )
+        _, _, provider_key = _prompt_llm_provider(env_path)
+        _prompt_embedding_provider(env_path, provider_key)
+    else:
+        typer.echo(
+            "\nYour LLM provider doesn't support text embeddings — Reflexio "
+            "needs an embedding model for semantic search."
+        )
+        non_embedding_provider = next(
+            p for p in providers if p not in EMBEDDING_CAPABLE_PROVIDERS
+        )
+        _prompt_embedding_provider(env_path, non_embedding_provider)
+
+    load_dotenv(dotenv_path=env_path, override=True)
+    typer.echo()
+
+
+def validate_storage_backend(storage: str | None) -> None:
+    """Validate and apply a storage backend selection.
+
+    If *storage* is not None, validates it against known backends and sets
+    the ``REFLEXIO_STORAGE`` environment variable.
+
+    .. deprecated::
+        Prefer :func:`reflexio.cli.bootstrap_config.resolve_storage` which
+        implements the full priority chain (CLI flag > env var > config > default)
+        and config file persistence.
+
+    Args:
+        storage: Storage backend name (e.g. ``"sqlite"``, ``"supabase"``),
+            or None to skip validation.
+
+    Raises:
+        typer.BadParameter: If *storage* is not a recognised backend.
+    """
+    if storage is None:
+        return
+    storage_lower = storage.lower()
+    if storage_lower not in _VALID_STORAGE_BACKENDS:
+        raise typer.BadParameter(
+            f"Invalid storage backend '{storage}'. "
+            f"Must be one of: {', '.join(sorted(_VALID_STORAGE_BACKENDS))}"
+        )
+    os.environ["REFLEXIO_STORAGE"] = storage_lower
+
+
+@app.command()
+def start(
+    backend_port: Annotated[
+        int | None, typer.Option(help="Backend server port (default: 8081)")
+    ] = None,
+    docs_port: Annotated[
+        int | None, typer.Option(help="Docs server port (default: 8082)")
+    ] = None,
+    embedding_port: Annotated[
+        int | None, typer.Option(help="Embedding service port (default: 8072)")
+    ] = None,
+    only: Annotated[
+        str | None,
+        typer.Option(help="Comma-separated services: backend,docs,embedding"),
+    ] = None,
+    no_reload: Annotated[
+        bool, typer.Option("--no-reload", help="Disable uvicorn auto-reload")
+    ] = False,
+    storage: Annotated[
+        str | None,
+        typer.Option(
+            help=(
+                "Storage backend to use (sqlite, supabase, or postgres). "
+                "See deployment docs for additional enterprise backends."
+            )
+        ),
+    ] = None,
+    workers: Annotated[
+        int,
+        typer.Option(
+            "--workers",
+            help=(
+                "Number of backend worker processes (daemon mode only). "
+                "Default 2 enables zero-downtime worker recycling."
+            ),
+        ),
+    ] = 2,
+    max_requests: Annotated[
+        int,
+        typer.Option(
+            "--max-requests",
+            help="Worker recycles after this many requests (0 disables). Default 10000.",
+        ),
+    ] = 10000,
+    max_requests_jitter: Annotated[
+        int,
+        typer.Option("--max-requests-jitter", help="Random 0..jitter per worker."),
+    ] = 1000,
+    graceful_shutdown_sec: Annotated[
+        int,
+        typer.Option(
+            "--graceful-shutdown-sec",
+            help="Seconds to drain in-flight requests on shutdown.",
+        ),
+    ] = 30,
+) -> None:
+    """Start Reflexio services (backend, docs)."""
+    from reflexio.cli.bootstrap_config import resolve_storage, save_storage_to_config
+    from reflexio.cli.env_loader import get_env_path, load_reflexio_env
+
+    # Load .env BEFORE resolve_storage so env vars from ~/.reflexio/.env
+    # (e.g. REFLEXIO_STORAGE=supabase) are visible to the resolution chain.
+    load_reflexio_env()
+
+    if (
+        not os.environ.get("REFLEXIO_EMBEDDING_PROVIDER")
+        and os.environ.get("CLAUDE_SMART_USE_LOCAL_EMBEDDING") == "1"
+    ):
+        os.environ["REFLEXIO_EMBEDDING_PROVIDER"] = "local_service"
+
+    selected_services = run_mod.parse_only_flag(only, {"backend", "docs"})
+
+    # First-run guard: if the backend's lifespan validator would reject the
+    # current env (no LLM key, or no embedding-capable provider), prompt now
+    # so users see a friendly wizard instead of a lifespan traceback.
+    if "backend" in selected_services:
+        _ensure_llm_configured(get_env_path())
+
+    resolved = resolve_storage(storage)
+    os.environ["REFLEXIO_STORAGE"] = resolved
+
+    # If user explicitly passed --storage, also persist to config and .env
+    if storage is not None:
+        save_storage_to_config(resolved)
+
+        from reflexio.cli.env_loader import set_env_var
+
+        env_path = get_env_path()
+        if env_path.exists():
+            set_env_var(env_path, "REFLEXIO_STORAGE", resolved)
+
+    args = argparse.Namespace(
+        backend_port=backend_port,
+        docs_port=docs_port,
+        embedding_port=embedding_port,
+        only=only,
+        no_reload=no_reload,
+        workers=workers,
+        max_requests=max_requests,
+        max_requests_jitter=max_requests_jitter,
+        graceful_shutdown_sec=graceful_shutdown_sec,
+    )
+    run_mod.execute(args)
+
+
+@app.command()
+def stop(
+    backend_port: Annotated[
+        int | None, typer.Option(help="Backend server port (default: 8081)")
+    ] = None,
+    docs_port: Annotated[
+        int | None, typer.Option(help="Docs server port (default: 8082)")
+    ] = None,
+    embedding_port: Annotated[
+        int | None, typer.Option(help="Embedding service port (default: 8072)")
+    ] = None,
+    only: Annotated[
+        str | None,
+        typer.Option(help="Comma-separated services: backend,docs,embedding"),
+    ] = None,
+    force: Annotated[bool, typer.Option("--force", help="SIGKILL immediately")] = False,
+) -> None:
+    """Stop Reflexio services."""
+    args = argparse.Namespace(
+        backend_port=backend_port,
+        docs_port=docs_port,
+        embedding_port=embedding_port,
+        only=only,
+        force=force,
+    )
+    stop_mod.execute(args)