claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/cli/__main__.py

@@ -0,0 +1,56 @@
+"""Reflexio CLI entry point.
+
+Usage:
+    reflexio [--json] [--url URL] [--api-key KEY] COMMAND [OPTIONS]
+
+Command groups:
+    reflexio services         start|stop
+    reflexio interactions     publish|list|search|delete|delete-all
+    reflexio profiles         list|search|delete|delete-all|generate
+    reflexio feedbacks        list|search|delete|delete-all|aggregate|regenerate
+    reflexio raw-feedbacks    list|search|add|delete|delete-all
+    reflexio config           show|set
+    reflexio auth             login|status|logout|setup
+    reflexio status           check
+    reflexio api              METHOD PATH
+    reflexio doctor           check
+
+Shortcuts:
+    reflexio publish      (alias for: interactions publish)
+    reflexio search       (unified search across profiles and feedbacks)
+    reflexio context      (fetch formatted context for agent injection)
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Main CLI entry point.
+
+    Loads ``~/.reflexio/.env`` so every CLI invocation (including those
+    spawned by hooks) picks up ``REFLEXIO_URL`` and ``REFLEXIO_API_KEY``.
+
+    Checks for registered CLI extensions (e.g. enterprise) via the
+    ``reflexio.cli`` entry-point group before falling back to the
+    default open-source app factory.
+    """
+    from reflexio.cli.env_loader import load_reflexio_env
+
+    load_reflexio_env()
+
+    from importlib.metadata import entry_points
+
+    eps = entry_points(group="reflexio.cli")
+    if eps:
+        create_app = next(iter(eps)).load()
+    else:
+        from reflexio.cli.app import create_app
+
+    app = create_app()
+    app(argv if argv is not None else sys.argv[1:], standalone_mode=True)
+
+
+if __name__ == "__main__":
+    main()

package/plugin/vendor/reflexio/reflexio/cli/_client.py

@@ -0,0 +1,86 @@
+"""ReflexioClient factory with layered config resolution.
+
+All connection settings come from CLI flags, environment variables
+(typically loaded from ``~/.reflexio/.env`` at CLI startup), or
+hard-coded defaults. No separate config file is used.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+
+from reflexio import ReflexioClient
+from reflexio.defaults import DEFAULT_AGENT_VERSION, DEFAULT_SERVER_URL, DEFAULT_USER_ID
+
+
+def _resolve(
+    args: argparse.Namespace | None,
+    arg_name: str,
+    env_var: str,
+    default: str,
+) -> str:
+    """Resolve a config value through the priority chain: CLI flag -> env var -> default.
+
+    Args:
+        args (argparse.Namespace | None): Parsed CLI arguments
+        arg_name (str): Attribute name on the args namespace
+        env_var (str): Environment variable name
+        default (str): Fallback default value
+
+    Returns:
+        str: The resolved value
+    """
+    if args and hasattr(args, arg_name) and getattr(args, arg_name):
+        return getattr(args, arg_name)
+    if env_val := os.environ.get(env_var):
+        return env_val
+    return default
+
+
+def create_client(args: argparse.Namespace | None = None) -> ReflexioClient:
+    """Create a ReflexioClient with config resolved from CLI flags, env vars, and defaults.
+
+    Resolution order (highest to lowest priority):
+        1. CLI flags (args.url, args.api_key)
+        2. Environment variables (REFLEXIO_URL, REFLEXIO_API_KEY)
+        3. Defaults (https://www.reflexio.ai/, no api_key)
+
+    Args:
+        args (argparse.Namespace | None): Parsed CLI arguments, or None for env/defaults only
+
+    Returns:
+        ReflexioClient: Configured client instance
+    """
+    url = _resolve(args, "url", "REFLEXIO_URL", DEFAULT_SERVER_URL)
+    api_key = _resolve(args, "api_key", "REFLEXIO_API_KEY", "")
+    return ReflexioClient(url_endpoint=url, api_key=api_key)
+
+
+def resolve_user_id(args: argparse.Namespace | None = None) -> str:
+    """Resolve user_id from CLI flags, env var, or default.
+
+    Args:
+        args (argparse.Namespace | None): Parsed CLI arguments
+
+    Returns:
+        str: Resolved user ID
+    """
+    return _resolve(args, "user_id", "REFLEXIO_USER_ID", DEFAULT_USER_ID)
+
+
+def resolve_agent_version(args: argparse.Namespace | None = None) -> str:
+    """Resolve agent_version from CLI flags, env var, or default.
+
+    Args:
+        args (argparse.Namespace | None): Parsed CLI arguments
+
+    Returns:
+        str: Resolved agent version
+    """
+    return _resolve(
+        args,
+        "agent_version",
+        "REFLEXIO_AGENT_VERSION",
+        DEFAULT_AGENT_VERSION,
+    )

package/plugin/vendor/reflexio/reflexio/cli/app.py

@@ -0,0 +1,127 @@
+"""Typer app factory for Reflexio CLI.
+
+Creates the root app with global flags, registers all command groups
+as sub-apps, and provides the entry point for both open-source and
+enterprise CLI variants.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from reflexio import __version__
+from reflexio.cli.state import CliState
+
+
+def _version_callback(value: bool) -> None:
+    """Print version and exit.
+
+    Args:
+        value: Whether the --version flag was passed
+    """
+    if value:
+        typer.echo(f"reflexio {__version__}")
+        raise typer.Exit
+
+
+def create_app(exclude: set[str] | None = None) -> typer.Typer:
+    """Create and configure the root Typer application.
+
+    Registers global flags (--json, --url, --api-key, --version) and
+    all command group sub-apps.
+
+    Args:
+        exclude: Optional set of sub-app names to skip registration for.
+            Allows consumers to replace specific sub-apps (e.g., ``exclude={"services"}``
+            to provide a custom services implementation).
+
+    Returns:
+        typer.Typer: The configured root application
+    """
+    app = typer.Typer(
+        name="reflexio",
+        help="Reflexio CLI — AI agent memory and feedback system",
+        no_args_is_help=True,
+        rich_markup_mode="rich",
+    )
+
+    @app.callback()
+    def main_callback(
+        ctx: typer.Context,
+        json_mode: Annotated[
+            bool,
+            typer.Option("--json", help="Output structured JSON envelopes"),
+        ] = False,
+        server_url: Annotated[
+            str | None,
+            typer.Option(
+                "--server-url", help="Backend API server URL", envvar="REFLEXIO_URL"
+            ),
+        ] = None,
+        api_key: Annotated[
+            str | None,
+            typer.Option(
+                "--api-key", help="Reflexio API key", envvar="REFLEXIO_API_KEY"
+            ),
+        ] = None,
+        _version: Annotated[  # noqa: ARG001 — Typer requires this param for the callback
+            bool,
+            typer.Option(
+                "--version",
+                callback=_version_callback,
+                is_eager=True,
+                help="Show version",
+            ),
+        ] = False,
+    ) -> None:
+        """Reflexio CLI — AI agent memory and feedback system."""
+        ctx.ensure_object(CliState)
+        ctx.obj.json_mode = json_mode
+        if server_url:
+            ctx.obj.server_url = server_url
+        if api_key:
+            ctx.obj.api_key = api_key
+
+    # Register command groups
+    from reflexio.cli.commands.admin_cmd import app as admin_app
+    from reflexio.cli.commands.agent_playbooks import app as agent_playbooks_app
+    from reflexio.cli.commands.api import app as api_app
+    from reflexio.cli.commands.auth import app as auth_app
+    from reflexio.cli.commands.config_cmd import app as config_app
+    from reflexio.cli.commands.doctor import app as doctor_app
+    from reflexio.cli.commands.embeddings import app as embeddings_app
+    from reflexio.cli.commands.interactions import app as interactions_app
+    from reflexio.cli.commands.profiles import app as profiles_app
+    from reflexio.cli.commands.services import app as services_app
+    from reflexio.cli.commands.setup_cmd import app as setup_app
+    from reflexio.cli.commands.shortcuts import register_shortcuts
+    from reflexio.cli.commands.status_cmd import app as status_app
+    from reflexio.cli.commands.user_playbooks import app as user_playbooks_app
+
+    _skip = exclude or set()
+
+    _sub_apps: list[tuple[typer.Typer, str]] = [
+        (services_app, "services"),
+        (embeddings_app, "embeddings"),
+        (interactions_app, "interactions"),
+        (profiles_app, "user-profiles"),
+        (agent_playbooks_app, "agent-playbooks"),
+        (user_playbooks_app, "user-playbooks"),
+        (config_app, "config"),
+        (auth_app, "auth"),
+        (status_app, "status"),
+        (api_app, "api"),
+        (doctor_app, "doctor"),
+        (setup_app, "setup"),
+        (admin_app, "admin"),
+    ]
+    for sub_app, name in _sub_apps:
+        if name not in _skip:
+            app.add_typer(sub_app, name=name)
+
+    # Top-level shortcuts (publish, search, context)
+    register_shortcuts(app)
+
+    return app

package/plugin/vendor/reflexio/reflexio/cli/bootstrap_config.py

@@ -0,0 +1,265 @@
+"""CLI bootstrap config: resolve and persist storage settings without a running server.
+
+Provides the priority chain: CLI flag > env var (.env) > config file > default.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from .paths import reflexio_home
+
+logger = logging.getLogger(__name__)
+
+_VALID_STORAGE_BACKENDS = frozenset({"sqlite", "supabase", "postgres"})
+_DEFAULT_ORG_ID = "self-host-org"
+_DEFAULT_STORAGE = "sqlite"
+
+# Maps StorageConfig subclass to backend string.  Lazy-imported in functions
+# that need it so module-level import stays lightweight (no Pydantic at import).
+_TYPE_TO_BACKEND: dict[type, str] = {}  # populated on first use
+
+
+def _data_db_url_from_env() -> str:
+    """Resolve the canonical data DB URL, accepting the legacy alias."""
+    return os.environ.get("DATA_DB_URL", "") or os.environ.get(
+        "DATA_SUPABASE_DB_URL", ""
+    )
+
+
+def _ensure_type_map() -> dict[type, str]:
+    """Lazy-build the StorageConfig type → backend string map."""
+    if not _TYPE_TO_BACKEND:
+        from reflexio.models.config_schema import (
+            StorageConfigPostgres,
+            StorageConfigSQLite,
+            StorageConfigSupabase,
+        )
+
+        _TYPE_TO_BACKEND.update(
+            {
+                StorageConfigSQLite: "sqlite",
+                StorageConfigSupabase: "supabase",
+                StorageConfigPostgres: "postgres",
+            }
+        )
+    return _TYPE_TO_BACKEND
+
+
+def _config_dir(base_dir: str | None = None) -> Path:
+    """Return the config directory path."""
+    if base_dir:
+        return Path(base_dir) / "configs"
+    return reflexio_home() / "configs"
+
+
+def default_config_path(base_dir: str | None = None) -> Path:
+    """Return the local config file path for the default self-host org.
+
+    Shared helper so CLI display commands (e.g. ``config show``,
+    ``config local``) resolve the same path without duplicating the
+    ``<dir>/config_<org>.json`` convention.
+
+    Args:
+        base_dir: Override base directory (for testing). If None, uses ~/.reflexio/.
+
+    Returns:
+        Path: Absolute path to the default-org config file (may not exist).
+    """
+    return _config_dir(base_dir) / f"config_{_DEFAULT_ORG_ID}.json"
+
+
+def load_storage_from_config(
+    org_id: str = _DEFAULT_ORG_ID,
+    *,
+    base_dir: str | None = None,
+) -> str | None:
+    """Read storage type from the local config file.
+
+    Args:
+        org_id: Organization ID for the config file name.
+        base_dir: Override base directory (for testing). If None, uses ~/.reflexio/.
+
+    Returns:
+        Storage backend string ("sqlite", "supabase", "postgres") or None if
+        no config file exists or storage_config is unset.
+    """
+    config_path = _config_dir(base_dir) / f"config_{org_id}.json"
+    if not config_path.exists():
+        return None
+
+    try:
+        from reflexio.server.services.configurator.local_file_config_storage import (
+            LocalFileConfigStorage,
+        )
+
+        storage = LocalFileConfigStorage(org_id, base_dir=base_dir)
+        config = storage.load_config()
+    except Exception:
+        logger.debug("Failed to load config from %s", config_path, exc_info=True)
+        return None
+
+    sc = config.storage_config
+    if sc is None:
+        return None
+
+    type_map = _ensure_type_map()
+    return type_map.get(type(sc))
+
+
+def save_storage_to_config(
+    storage_type: str,
+    org_id: str = _DEFAULT_ORG_ID,
+    *,
+    base_dir: str | None = None,
+) -> None:
+    """Update storage_config in the local config file.
+
+    Loads the existing config, replaces only ``storage_config``, and saves.
+    All other fields (extractors, api_keys, etc.) are preserved.
+
+    Args:
+        storage_type: Backend name ("sqlite", "supabase", "postgres").
+        org_id: Organization ID for the config file name.
+        base_dir: Override base directory (for testing).
+    """
+    from reflexio.models.config_schema import (
+        StorageConfigPostgres,
+        StorageConfigSQLite,
+        StorageConfigSupabase,
+    )
+    from reflexio.server.services.configurator.local_file_config_storage import (
+        LocalFileConfigStorage,
+    )
+
+    storage_obj = LocalFileConfigStorage(org_id, base_dir=base_dir)
+    config = storage_obj.load_config()
+
+    match storage_type:
+        case "sqlite":
+            config.storage_config = StorageConfigSQLite()
+        case "supabase":
+            url = os.environ.get("DATA_SUPABASE_URL", "")
+            key = os.environ.get("DATA_SUPABASE_KEY", "")
+            db_url = _data_db_url_from_env()
+            if url and key and db_url:
+                config.storage_config = StorageConfigSupabase(
+                    url=url, key=key, db_url=db_url
+                )
+            else:
+                logger.warning(
+                    "Supabase storage requested but credentials are missing "
+                    "(DATA_SUPABASE_URL, DATA_SUPABASE_KEY, DATA_DB_URL). "
+                    "Keeping existing storage config."
+                )
+        case "postgres":
+            db_url = os.environ.get("DATA_DB_URL", "").strip()
+            schema = os.environ.get("REFLEXIO_POSTGRES_SCHEMA", "").strip()
+            pool_size_raw = os.environ.get("REFLEXIO_POSTGRES_POOL_SIZE", "").strip()
+            pool_size = int(pool_size_raw) if pool_size_raw.isdigit() else 10
+            if pool_size < 1:
+                logger.warning(
+                    "Invalid REFLEXIO_POSTGRES_POOL_SIZE=%r (must be >= 1); using default",
+                    pool_size_raw,
+                )
+                pool_size = 10
+            timeout_raw = os.environ.get(
+                "REFLEXIO_POSTGRES_POOL_ACQUIRE_TIMEOUT", ""
+            ).strip()
+            postgres_kwargs: dict[str, Any] = {
+                "db_url": db_url,
+                "schema": schema or None,
+                "pool_size": pool_size,
+            }
+            if timeout_raw:
+                try:
+                    timeout = float(timeout_raw)
+                except ValueError:
+                    logger.warning(
+                        "Invalid REFLEXIO_POSTGRES_POOL_ACQUIRE_TIMEOUT=%r; using default",
+                        timeout_raw,
+                    )
+                else:
+                    if timeout > 0:
+                        postgres_kwargs["pool_acquire_timeout"] = timeout
+                    else:
+                        logger.warning(
+                            "Invalid REFLEXIO_POSTGRES_POOL_ACQUIRE_TIMEOUT=%r "
+                            "(must be > 0); using default",
+                            timeout_raw,
+                        )
+            if db_url:
+                config.storage_config = StorageConfigPostgres(**postgres_kwargs)
+            else:
+                logger.warning(
+                    "Postgres storage requested but DATA_DB_URL "
+                    "is missing. Keeping existing storage config."
+                )
+        case _:
+            raise ValueError(f"Unknown storage type: {storage_type}")
+
+    storage_obj.save_config(config)
+
+
+def resolve_storage(cli_flag: str | None) -> str:
+    """Resolve storage backend using priority: CLI flag > env var > config file > default.
+
+    Do NOT use Typer's ``envvar=`` binding for ``--storage``. This function
+    handles the full resolution chain so callers can distinguish explicit CLI
+    flags (``cli_flag is not None``) from implicit fallback (``cli_flag is None``)
+    for write-back decisions.
+
+    Args:
+        cli_flag: Value from ``--storage`` flag, or ``None`` if not passed.
+
+    Returns:
+        Resolved storage backend string.
+
+    Raises:
+        typer.BadParameter: If the resolved value is not a known backend.
+    """
+    # 1. CLI flag (explicit user intent)
+    if cli_flag is not None:
+        result = cli_flag.lower()
+        if result not in _VALID_STORAGE_BACKENDS:
+            raise typer.BadParameter(
+                f"Invalid storage backend '{cli_flag}'. "
+                f"Must be one of: {', '.join(sorted(_VALID_STORAGE_BACKENDS))}"
+            )
+        return result
+
+    # 2. Environment variable (from .env or shell)
+    env_val = os.environ.get("REFLEXIO_STORAGE")
+    if env_val:
+        env_norm = env_val.lower()
+        if env_norm in _VALID_STORAGE_BACKENDS:
+            return env_norm
+        # Unknown value (e.g., legacy "disk" or a typo). Don't silently fall
+        # through — surface a warning so operators notice that their env var
+        # was ignored. Common case: REFLEXIO_STORAGE=disk left over from a
+        # release that supported the now-removed disk backend.
+        legacy_hint = (
+            " The 'disk' backend was removed; migrate to 'sqlite'."
+            if env_norm == "disk"
+            else ""
+        )
+        logger.warning(
+            "Ignoring unsupported REFLEXIO_STORAGE=%r; falling back to config/default. "
+            "Supported: %s.%s",
+            env_val,
+            ", ".join(sorted(_VALID_STORAGE_BACKENDS)),
+            legacy_hint,
+        )
+
+    # 3. Config file
+    from_config = load_storage_from_config()
+    if from_config and from_config in _VALID_STORAGE_BACKENDS:
+        return from_config
+
+    # 4. Hardcoded default
+    return _DEFAULT_STORAGE