claude-smart 0.2.41 → 0.2.43

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

@@ -0,0 +1,373 @@
+"""User playbook management commands (list, search, add, delete, regenerate)."""
+
+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_playbooks,
+    render,
+)
+from reflexio.cli.state import get_client, require_agent_version
+
+app = typer.Typer(help="Manage user playbooks.")
+
+_STATUS_MAP = {
+    "current": "current",
+    "pending": "pending",
+    "archived": "archived",
+}
+
+
+@app.command(name="list")
+@handle_errors
+def list_user_playbooks(
+    ctx: typer.Context,
+    user_id: Annotated[
+        str | None,
+        typer.Option("--user-id", help="Filter by user ID"),
+    ] = None,
+    limit: Annotated[
+        int,
+        typer.Option("--limit", help="Maximum number of playbooks to return"),
+    ] = 20,
+    playbook_name: Annotated[
+        str | None,
+        typer.Option("--playbook-name", help="Filter by playbook name"),
+    ] = None,
+    agent_version: Annotated[
+        str | None,
+        typer.Option("--agent-version", help="Filter by agent version"),
+    ] = None,
+    status: Annotated[
+        str | None,
+        typer.Option("--status", help="Status filter (current/pending/archived)"),
+    ] = None,
+) -> None:
+    """List user playbooks.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        user_id: Optional user ID filter
+        limit: Maximum number of playbooks to return
+        playbook_name: Optional playbook name filter
+        agent_version: Optional agent version filter
+        status: Optional status filter (current, pending, archived)
+    """
+    from reflexio.models.api_schema.service_schemas import Status
+
+    if status and status not in _STATUS_MAP:
+        raise CliError(
+            error_type="validation",
+            message=f"Invalid status: {status}. Must be current, pending, or archived.",
+            exit_code=EXIT_VALIDATION,
+        )
+
+    status_filter: list[Status | None] | None = None
+    if status == "current":
+        status_filter = [Status.CURRENT]
+    elif status == "pending":
+        status_filter = [Status.PENDING]
+    elif status == "archived":
+        status_filter = [Status.ARCHIVED]
+
+    client = get_client(ctx)
+    resp = client.get_user_playbooks(
+        limit=limit,
+        user_id=user_id,
+        playbook_name=playbook_name,
+        agent_version=agent_version,
+        status_filter=status_filter,
+    )
+    playbooks = resp.user_playbooks or []
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(playbooks, json_mode=True, meta=pagination_meta(playbooks, limit))
+    else:
+        print_info(f"Found {len(playbooks)} user playbook(s)")
+        if playbooks:
+            print_user_playbooks(playbooks)
+
+
+@app.command()
+@handle_errors
+def search(
+    ctx: typer.Context,
+    query: Annotated[
+        str,
+        typer.Argument(help="Semantic search query for user playbooks"),
+    ],
+    limit: Annotated[
+        int,
+        typer.Option("--limit", help="Maximum number of results"),
+    ] = 10,
+    agent_version: Annotated[
+        str | None,
+        typer.Option("--agent-version", help="Agent version to filter by"),
+    ] = None,
+) -> None:
+    """Search user playbooks by semantic query.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        query: Search query string
+        limit: Maximum number of results
+        agent_version: Optional agent version filter
+    """
+    client = get_client(ctx)
+
+    resp = client.search_user_playbooks(
+        query=query,
+        agent_version=agent_version,
+        top_k=limit,
+    )
+    playbooks = resp.user_playbooks or []
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(playbooks, json_mode=True, meta=pagination_meta(playbooks, limit))
+    else:
+        print_info(f"Found {len(playbooks)} user playbook(s)")
+        if playbooks:
+            print_user_playbooks(playbooks)
+
+
+@app.command()
+@handle_errors
+def add(
+    ctx: typer.Context,
+    content: Annotated[
+        str,
+        typer.Option("--content", help="Playbook content text"),
+    ],
+    playbook_name: Annotated[
+        str,
+        typer.Option("--playbook-name", help="Playbook category name"),
+    ] = "agent_corrections",
+    trigger: Annotated[
+        str | None,
+        typer.Option("--trigger", help="When this playbook applies"),
+    ] = None,
+    rationale: Annotated[
+        str | None,
+        typer.Option("--rationale", help="Why this playbook matters"),
+    ] = None,
+    agent_version: Annotated[
+        str | None,
+        typer.Option(
+            "--agent-version",
+            help="Agent version to tag this playbook with (defaults to 'cli')",
+        ),
+    ] = None,
+) -> None:
+    """Add a manual user playbook entry.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        content: Playbook content text
+        playbook_name: Playbook category name
+        trigger: When this playbook applies
+        rationale: Why this playbook matters
+        agent_version: Agent version label to scope the playbook to;
+            defaults to "cli" so CLI-authored entries stay isolated from
+            integration-authored ones (e.g. ``openclaw-agent``).
+    """
+    from reflexio.models.api_schema.service_schemas import UserPlaybook
+
+    playbook = UserPlaybook(
+        agent_version=agent_version or "cli",
+        request_id="cli-manual",
+        playbook_name=playbook_name,
+        content=content,
+        trigger=trigger,
+        rationale=rationale,
+    )
+
+    client = get_client(ctx)
+    resp = client.add_user_playbook([playbook])
+
+    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 playbook")
+        print_info(f"User playbook added: {content[:80]}")
+
+
+@app.command()
+@handle_errors
+def update(
+    ctx: typer.Context,
+    playbook_id: Annotated[
+        int,
+        typer.Option("--playbook-id", help="User playbook ID to update"),
+    ],
+    content: Annotated[
+        str | None,
+        typer.Option("--content", help="New content text"),
+    ] = None,
+    playbook_name: Annotated[
+        str | None,
+        typer.Option("--playbook-name", help="New playbook category name"),
+    ] = None,
+) -> None:
+    """Update editable fields of a user playbook.
+
+    Pass only the fields you want to change. Currently supports
+    ``--content`` and ``--playbook-name``.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        playbook_id: User playbook ID to update
+        content: New content text
+        playbook_name: New playbook category name
+    """
+    if content is None and playbook_name is None:
+        raise CliError(
+            error_type="validation",
+            message=("Pass at least one of --content/--playbook-name to update."),
+            exit_code=EXIT_VALIDATION,
+        )
+
+    client = get_client(ctx)
+    resp = client.update_user_playbook(
+        user_playbook_id=playbook_id,
+        content=content,
+        playbook_name=playbook_name,
+    )
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(resp, json_mode=True)
+    else:
+        raise_if_failed(resp, default="Failed to update user playbook")
+        print_info(f"User playbook {playbook_id} updated")
+
+
+@app.command()
+@handle_errors
+def delete(
+    ctx: typer.Context,
+    playbook_id: Annotated[
+        str,
+        typer.Option("--playbook-id", help="User playbook ID"),
+    ],
+) -> None:
+    """Delete a user playbook by ID.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        playbook_id: User playbook ID to delete
+    """
+    client = get_client(ctx)
+    resp = client.delete_user_playbook(
+        user_playbook_id=int(playbook_id),
+        wait_for_response=True,
+    )
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(resp, json_mode=True)
+    else:
+        print_info(f"Deleted user playbook {playbook_id}")
+
+
+@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 user playbooks (user only, not agent playbooks).
+
+    Uses the dedicated ``DELETE /api/delete_all_user_playbooks`` endpoint,
+    which is scoped strictly to user playbooks. To also wipe agent
+    playbooks, run ``reflexio agent-playbooks delete-all`` separately.
+
+    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 user playbooks?")
+        if not confirmed:
+            raise typer.Abort()
+
+    client = get_client(ctx)
+    resp = client.delete_all_user_playbooks()
+
+    json_mode: bool = ctx.obj.json_mode
+    if json_mode:
+        render(resp, json_mode=True)
+    else:
+        print_info("All user playbooks deleted")
+
+
+@app.command()
+@handle_errors
+def regenerate(
+    ctx: typer.Context,
+    wait: Annotated[
+        bool,
+        typer.Option("--wait", help="Wait for regeneration to complete"),
+    ] = False,
+    agent_version: Annotated[
+        str | None,
+        typer.Option(
+            "--agent-version", help="Agent version to regenerate playbooks for"
+        ),
+    ] = None,
+) -> None:
+    """Re-extract user playbooks from published interactions.
+
+    Re-runs the playbook extraction pipeline over all interactions for the
+    given agent version, producing fresh user playbooks.
+
+    Args:
+        ctx: Typer context with CliState in ctx.obj
+        wait: If True, wait for regeneration to complete
+        agent_version: Agent version to regenerate (required)
+    """
+    client = get_client(ctx)
+    resolved_version = require_agent_version(
+        agent_version, command_hint="user-playbook regeneration"
+    )
+
+    resp = client.rerun_playbook_generation(
+        agent_version=resolved_version,
+        wait_for_response=wait,
+    )
+
+    # When waiting, auto-promote PENDING user playbooks to CURRENT so
+    # they're immediately visible in `list` output.
+    promoted = 0
+    if wait:
+        try:
+            upgrade_resp = client.upgrade_user_playbooks(
+                agent_version=resolved_version,
+            )
+            promoted = upgrade_resp.user_playbooks_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"Playbook regeneration complete ({promoted} playbook(s) promoted)")
+    else:
+        print_info("Playbook regeneration started")

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

@@ -0,0 +1,284 @@
+"""Shared .env discovery, loading, and mutation utility.
+
+Searches for .env in multiple locations. On first run, auto-creates
+~/.reflexio/.env from the bundled .env.example template.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+import logging
+import re
+import secrets
+import sys
+from pathlib import Path
+
+_logger = logging.getLogger(__name__)
+
+from dotenv import load_dotenv
+
+from .paths import reflexio_home
+
+_USER_ENV_DIR = reflexio_home()
+_USER_ENV_FILE = _USER_ENV_DIR / ".env"
+
+
+# Path to the .env file that load_reflexio_env last resolved — None until
+# load_reflexio_env runs for the first time. Exposed via get_loaded_env_path
+# so the startup banner can show the operator exactly which dotenv was
+# picked (./.env vs ~/.reflexio/.env vs auto-created).
+_loaded_env_path: Path | None = None
+
+
+def get_env_path() -> Path:
+    """Return the canonical path to the user-level .env file.
+
+    Returns:
+        Path: ``~/.reflexio/.env``
+    """
+    return _USER_ENV_FILE
+
+
+def get_loaded_env_path() -> Path | None:
+    """Return the .env path that the most recent ``load_reflexio_env`` call
+    resolved, or None if the loader hasn't run yet.
+
+    Used by the startup banner so operators can see at a glance which
+    dotenv file was actually consumed (``./.env`` wins over
+    ``~/.reflexio/.env`` when both exist).
+    """
+    return _loaded_env_path
+
+
+def set_env_var(env_path: Path, key: str, value: str) -> None:
+    """Write or update an environment variable in a .env file.
+
+    If the key already exists (active or commented-out), the line is replaced
+    in-place. Active (uncommented) lines are prioritized over commented ones.
+    Values are always wrapped in double quotes for safe parsing.
+
+    Args:
+        env_path (Path): Path to the .env file.
+        key (str): Environment variable name.
+        value (str): Environment variable value.
+    """
+    content = env_path.read_text() if env_path.exists() else ""
+    lines = content.splitlines()
+    pattern = re.compile(rf"^#?\s*{re.escape(key)}=")
+    active_idx: int | None = None
+    commented_idx: int | None = None
+    for i, line in enumerate(lines):
+        if not pattern.match(line):
+            continue
+        if line.lstrip().startswith("#"):
+            if commented_idx is None:
+                commented_idx = i
+        else:
+            active_idx = i
+            break
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    replacement = f'{key}="{escaped}"'
+    target = active_idx if active_idx is not None else commented_idx
+    if target is not None:
+        lines[target] = replacement
+    else:
+        lines.append(replacement)
+    env_path.write_text("\n".join(lines) + "\n")
+    env_path.chmod(0o600)
+
+
+_ENV_SEARCH_PATHS = [
+    Path(".env"),  # 1. Current directory (local dev / project-level)
+    _USER_ENV_FILE,  # 2. User home default (~/.reflexio/.env)
+]
+
+
+def load_reflexio_env(
+    *,
+    package_data_module: str = "reflexio.data",
+    auto_generate_keys: list[str] | None = None,
+) -> Path | None:
+    """Load .env from the first location found, or auto-create on first run.
+
+    Search order:
+        1. ./.env (current directory)
+        2. ~/.reflexio/.env (user home)
+        3. Auto-create from bundled .env.example template
+
+    Args:
+        package_data_module: Module containing bundled .env.example
+            (for importlib.resources). OS package uses "reflexio.data",
+            enterprise uses "reflexio_ext.data".
+        auto_generate_keys: Env var names to auto-generate as hex tokens
+            (e.g., ["JWT_SECRET_KEY"]).
+
+    Returns:
+        Path to the loaded .env file, or None if no .env was found/created.
+    """
+    global _loaded_env_path
+    for env_path in _ENV_SEARCH_PATHS:
+        if env_path.exists():
+            load_dotenv(dotenv_path=env_path)
+            resolved = env_path.resolve()
+            _logger.debug("Loaded env from: %s", resolved)
+            _loaded_env_path = resolved
+            # Auto-generate any missing secret keys into the existing .env
+            _backfill_missing_keys(env_path, auto_generate_keys or [])
+            return env_path
+
+    # No .env found — auto-create from bundled template
+    created = _create_default_env(package_data_module, auto_generate_keys or [])
+    if created is not None:
+        _loaded_env_path = created.resolve()
+    return created
+
+
+def ensure_user_env_for_setup(
+    *,
+    package_data_module: str = "reflexio.data",
+    auto_generate_keys: list[str] | None = None,
+) -> Path | None:
+    """Return ``~/.reflexio/.env``, creating it from the template if missing.
+
+    Distinct from :func:`load_reflexio_env`: that function honors a CWD-local
+    ``./.env`` (intentional for ``services start``, where a project-level
+    override should take precedence). For ``setup init`` we never want to
+    write to whatever ``.env`` happens to be in the user's CWD — they may be
+    running from a worktree or a project root with an unrelated ``.env``,
+    and the resulting writes pollute that file and break the documented
+    ``~/.reflexio/.env`` invariant.
+
+    Args:
+        package_data_module: Module containing the bundled ``.env.example``
+            template (for ``importlib.resources``). OS uses ``reflexio.data``,
+            enterprise uses ``reflexio_ext.data``.
+        auto_generate_keys: Env var names to auto-fill with random hex
+            tokens when creating from the template.
+
+    Returns:
+        Path to ``~/.reflexio/.env`` (existing or newly created), or
+        ``None`` if no template could be found.
+    """
+    global _loaded_env_path
+    if _USER_ENV_FILE.exists():
+        load_dotenv(dotenv_path=_USER_ENV_FILE)
+        resolved = _USER_ENV_FILE.resolve()
+        _logger.debug("Loaded user env from: %s", resolved)
+        _loaded_env_path = resolved
+        _backfill_missing_keys(_USER_ENV_FILE, auto_generate_keys or [])
+        return _USER_ENV_FILE
+    created = _create_default_env(package_data_module, auto_generate_keys or [])
+    if created is not None:
+        _loaded_env_path = created.resolve()
+    return created
+
+
+def _backfill_missing_keys(env_path: Path, keys: list[str]) -> None:
+    """Generate and write any missing secret keys into an existing .env file.
+
+    Called when ``load_reflexio_env`` finds a pre-existing .env (e.g. created
+    by ``setup init``) that may be missing keys that ``services start``
+    requires (like JWT_SECRET_KEY).
+
+    Args:
+        env_path: Path to the existing .env file.
+        keys: Env var names to check/generate.
+    """
+    import os
+
+    generated: list[str] = []
+    for key in keys:
+        if os.environ.get(key):
+            continue
+        token = secrets.token_hex(32)
+        set_env_var(env_path, key, token)
+        os.environ[key] = token
+        generated.append(key)
+    if generated:
+        sys.stdout.write(f"  Auto-generated missing keys: {', '.join(generated)}\n")
+        sys.stdout.flush()
+
+
+def _find_env_example(package_data_module: str) -> str | None:
+    """Find .env.example content from CWD or package data.
+
+    Args:
+        package_data_module: Dotted module path for importlib.resources lookup.
+
+    Returns:
+        The template content as a string, or None if not found anywhere.
+    """
+    # 1. Current directory (local dev checkout)
+    local = Path(".env.example")
+    if local.exists():
+        return local.read_text()
+
+    # 2. Package data (installed package)
+    try:
+        ref = importlib.resources.files(package_data_module).joinpath(".env.example")
+        return ref.read_text(encoding="utf-8")
+    except (ModuleNotFoundError, FileNotFoundError):  # fmt: skip
+        pass
+
+    # 3. Editable install: .env.example lives at project root, two levels above reflexio/
+    try:
+        import reflexio as _pkg
+
+        project_root = Path(_pkg.__file__).resolve().parent.parent
+        candidate = project_root / ".env.example"
+        if candidate.is_file():
+            return candidate.read_text()
+    except Exception:  # noqa: BLE001, S110
+        pass
+
+    return None
+
+
+def _create_default_env(
+    package_data_module: str,
+    auto_generate_keys: list[str],
+) -> Path | None:
+    """Create ~/.reflexio/.env from .env.example with auto-generated secrets.
+
+    Args:
+        package_data_module: Module path for finding the .env.example template.
+        auto_generate_keys: Env var names to auto-fill with random hex tokens.
+
+    Returns:
+        Path to the newly created .env file, or None if template not found.
+    """
+    content = _find_env_example(package_data_module)
+    if content is None:
+        sys.stdout.write(
+            "Warning: no .env file found and no .env.example template available.\n"
+            "  Set required environment variables manually.\n"
+        )
+        sys.stdout.flush()
+        return None
+
+    created_dir = not _USER_ENV_DIR.exists()
+    _USER_ENV_DIR.mkdir(parents=True, exist_ok=True)
+    if created_dir:
+        sys.stdout.write(f"Created directory: {_USER_ENV_DIR}\n")
+
+    # Auto-generate secret keys
+    for key in auto_generate_keys:
+        token = secrets.token_hex(32)
+        content = re.sub(
+            rf"^{re.escape(key)}=.*$",
+            f"{key}={token}",
+            content,
+            count=1,
+            flags=re.MULTILINE,
+        )
+
+    _USER_ENV_FILE.write_text(content)
+    _USER_ENV_FILE.chmod(0o600)
+    load_dotenv(dotenv_path=_USER_ENV_FILE)
+
+    sys.stdout.write(f"Created env file: {_USER_ENV_FILE}\n")
+    if auto_generate_keys:
+        sys.stdout.write(f"  Auto-generated: {', '.join(auto_generate_keys)}\n")
+    sys.stdout.write(f"  Edit {_USER_ENV_FILE} to add your API keys.\n\n")
+    sys.stdout.flush()
+    return _USER_ENV_FILE