claude-smart 0.2.30 → 0.2.32

package/plugin/scripts/smart-install.sh

@@ -14,6 +14,7 @@ HERE="$(cd "$(dirname "$0")" && pwd)"
 claude_smart_source_login_path
 claude_smart_prepend_astral_bins
 claude_smart_prepend_node_bins
+claude_smart_source_reflexio_env
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
 REPO_ROOT="$(cd "$HERE/../.." && pwd)"
@@ -47,7 +48,7 @@ acquire_install_lock() {
     exec 9>"$INSTALL_LOCK"
     if ! flock 9; then
       echo "[claude-smart] install lock failed; continuing without serialization" >&2
-      echo '{"continue":true,"suppressOutput":true}'
+      claude_smart_emit_continue
       exit 0
     fi
     return 0
@@ -80,45 +81,23 @@ acquire_install_lock
 rm -f "$FAILURE_MARKER"
 
 write_failure() {
-  local reason
+  local reason fp_hash
   reason="$1"
-  printf '%s\n' "$reason" > "$FAILURE_MARKER"
+  fp_hash="$(claude_smart_install_fingerprint_hash "$PLUGIN_ROOT" "$HERE" 2>/dev/null || true)"
+  {
+    printf '%s\n' "$reason"
+    if [ -n "$fp_hash" ]; then
+      printf 'fingerprint=%s\n' "$fp_hash"
+    fi
+  } > "$FAILURE_MARKER"
   rm -f "$SUCCESS_MARKER"
   echo "[claude-smart] install failed: $reason" >&2
-  echo '{"continue":true,"suppressOutput":true}'
+  claude_smart_emit_continue
   exit 0
 }
 
-fingerprint_file() {
-  local path
-  path="$1"
-  if [ -f "$path" ]; then
-    cksum "$path" 2>/dev/null | awk '{print $1 ":" $2}'
-  else
-    printf 'missing\n'
-  fi
-}
-
 install_fingerprint() {
-  printf 'plugin_root=%s\n' "$PLUGIN_ROOT"
-  printf 'smart_install=%s\n' "$(fingerprint_file "$HERE/smart-install.sh")"
-  printf 'pyproject=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/pyproject.toml")"
-  printf 'uv_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/uv.lock")"
-  # Resolved python interpreter — catches a system upgrade (3.12.4 → 3.12.5)
-  # that would otherwise let install_complete return true against a venv
-  # built against a now-deleted interpreter.
-  if command -v uv >/dev/null 2>&1; then
-    printf 'python=%s\n' "$(uv python find 3.12 2>/dev/null || echo missing)"
-  else
-    printf 'python=no-uv\n'
-  fi
-  if [ -d "$PLUGIN_ROOT/dashboard" ]; then
-    printf 'dashboard_pkg=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package.json")"
-    printf 'dashboard_lock=%s\n' "$(fingerprint_file "$PLUGIN_ROOT/dashboard/package-lock.json")"
-  else
-    printf 'dashboard_pkg=none\n'
-    printf 'dashboard_lock=none\n'
-  fi
+  claude_smart_install_fingerprint "$PLUGIN_ROOT" "$HERE"
 }
 
 install_complete() {
@@ -127,8 +106,10 @@ install_complete() {
   command -v uv >/dev/null 2>&1 || return 1
   [ -d "$PLUGIN_ROOT/.venv" ] || return 1
   [ -f "$HOME/.reflexio/.env" ] || return 1
-  grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.reflexio/.env" || return 1
-  grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$HOME/.reflexio/.env" || return 1
+  if [ -z "${REFLEXIO_API_KEY:-}" ]; then
+    grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.reflexio/.env" || return 1
+    grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$HOME/.reflexio/.env" || return 1
+  fi
   if [ -d "$PLUGIN_ROOT/dashboard" ]; then
     [ -d "$PLUGIN_ROOT/dashboard/.next" ] || [ -f "$MARKER_DIR/dashboard-build.pid" ] || [ -f "$(claude_smart_dashboard_unavailable_marker)" ] || return 1
   fi
@@ -382,7 +363,7 @@ fi
 preflight_supported_runtime_platform
 
 if install_complete; then
-  echo '{"continue":true,"suppressOutput":true}'
+  claude_smart_emit_continue
   exit 0
 fi
 
@@ -453,13 +434,15 @@ fi
 REFLEXIO_ENV="$HOME/.reflexio/.env"
 mkdir -p "$(dirname "$REFLEXIO_ENV")"
 touch "$REFLEXIO_ENV"
-if ! grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$REFLEXIO_ENV"; then
-  printf '\n# Route reflexio generation through the local Claude Code CLI\nCLAUDE_SMART_USE_LOCAL_CLI=1\n' >> "$REFLEXIO_ENV"
-  echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_CLI=1 to $REFLEXIO_ENV" >&2
-fi
-if ! grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$REFLEXIO_ENV"; then
-  printf '# Use the in-process ONNX embedder (chromadb) — no API key for semantic search\nCLAUDE_SMART_USE_LOCAL_EMBEDDING=1\n' >> "$REFLEXIO_ENV"
-  echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_EMBEDDING=1 to $REFLEXIO_ENV" >&2
+if [ -z "${REFLEXIO_API_KEY:-}" ]; then
+  if ! grep -q '^CLAUDE_SMART_USE_LOCAL_CLI=' "$REFLEXIO_ENV"; then
+    printf '\n# Route reflexio generation through the local Claude Code CLI\nCLAUDE_SMART_USE_LOCAL_CLI=1\n' >> "$REFLEXIO_ENV"
+    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_CLI=1 to $REFLEXIO_ENV" >&2
+  fi
+  if ! grep -q '^CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$REFLEXIO_ENV"; then
+    printf '# Use the in-process ONNX embedder (chromadb) — no API key for semantic search\nCLAUDE_SMART_USE_LOCAL_EMBEDDING=1\n' >> "$REFLEXIO_ENV"
+    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_EMBEDDING=1 to $REFLEXIO_ENV" >&2
+  fi
 fi
 # Migrate stale REFLEXIO_URL from reflexio's library default (8081) to the
 # plugin backend port (8071). Matches the quoted and unquoted forms but
@@ -533,4 +516,4 @@ fi
 
 write_success_marker
 echo "[claude-smart] install complete. Backend and dashboard auto-start on session start." >&2
-echo '{"continue":true,"suppressOutput":true}'
+claude_smart_emit_continue

package/plugin/src/claude_smart/cli.py

@@ -33,10 +33,11 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 
-from claude_smart import context_format, ids, publish, state
+from claude_smart import context_format, env_config, ids, publish, state
 from claude_smart.reflexio_adapter import Adapter
 
-_REFLEXIO_ENV_PATH = Path.home() / ".reflexio" / ".env"
+_REFLEXIO_ENV_PATH = env_config.REFLEXIO_ENV_PATH
+_MANAGED_REFLEXIO_URL = env_config.MANAGED_REFLEXIO_URL
 _DEFAULT_MARKETPLACE_SOURCE = "ReflexioAI/claude-smart"
 _PLUGIN_SPEC = "claude-smart@reflexioai"
 _CODEX_MARKETPLACE_NAME = "reflexioai"
@@ -70,6 +71,16 @@ _BACKEND_SCRIPT = _SCRIPTS_DIR / "backend-service.sh"
 _DASHBOARD_SCRIPT = _SCRIPTS_DIR / "dashboard-service.sh"
 _REFLEXIO_DIR = Path.home() / ".reflexio"
 _STATE_DIR = Path.home() / ".claude-smart"
+_LOCAL_DATA_NOTICE = (
+    "Local data was kept so reinstalling claude-smart can reuse your learned "
+    "rules, sessions, logs, and local Reflexio data.\n"
+    "Kept folders:\n"
+    "  ~/.claude-smart\n"
+    "  ~/.reflexio\n"
+    "Delete them only if you want a full reset or need to remove local "
+    "claude-smart data from this machine:\n"
+    "  rm -rf ~/.claude-smart ~/.reflexio\n"
+)
 _INSTALL_FAILURE_MARKER = _STATE_DIR / "install-failed"
 _DEFAULT_STORAGE_ROOT = _REFLEXIO_DIR / "data"
 _REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / "config_self-host-org.json"
@@ -127,9 +138,21 @@ def _seed_reflexio_env() -> list[str]:
     prefix = "" if not existing or existing.endswith("\n") else "\n"
     with _REFLEXIO_ENV_PATH.open("a") as fh:
         fh.write(prefix + "\n".join(f"{f}=1" for f in missing) + "\n")
+    _REFLEXIO_ENV_PATH.chmod(0o600)
     return missing
 
 
+def _seed_managed_reflexio_env(*, api_key: str, reflexio_url: str) -> list[str]:
+    """Write managed Reflexio connection settings to ``~/.reflexio/.env``."""
+    return env_config.set_env_vars(
+        _REFLEXIO_ENV_PATH,
+        {
+            env_config.REFLEXIO_URL_ENV: reflexio_url,
+            env_config.REFLEXIO_API_KEY_ENV: api_key,
+        },
+    )
+
+
 def _find_claude_code_plugin_root() -> Path | None:
     """Locate the installed Claude Code plugin root after native install."""
     cache_root = (
@@ -162,10 +185,9 @@ def _find_claude_code_plugin_root() -> Path | None:
         ]
     )
     for candidate in candidates:
-        if (
-            (candidate / "pyproject.toml").is_file()
-            and (candidate / "scripts" / "smart-install.sh").is_file()
-        ):
+        if (candidate / "pyproject.toml").is_file() and (
+            candidate / "scripts" / "smart-install.sh"
+        ).is_file():
             return candidate
     return None
 
@@ -205,7 +227,8 @@ def _bootstrap_claude_code_install() -> tuple[bool, str]:
     if result.returncode != 0:
         return False, f"smart-install.sh failed in {plugin_root}"
     if _INSTALL_FAILURE_MARKER.is_file():
-        reason = _INSTALL_FAILURE_MARKER.read_text().strip() or "unknown error"
+        first_line = _INSTALL_FAILURE_MARKER.read_text().splitlines()
+        reason = (first_line[0].strip() if first_line else "") or "unknown error"
         return False, reason
     return True, str(plugin_root)
 
@@ -734,7 +757,26 @@ def _register_codex_marketplace(root: Path) -> tuple[bool, str]:
     return False, output or "Codex CLI does not expose plugin marketplace commands"
 
 
-def cmd_install_codex(_args: argparse.Namespace) -> int:
+def _configure_reflexio_setup(args: argparse.Namespace) -> None:
+    api_key = (getattr(args, "api_key", "") or "").strip()
+    if api_key:
+        reflexio_url = (
+            getattr(args, "reflexio_url", "") or _MANAGED_REFLEXIO_URL
+        ).strip()
+        added = _seed_managed_reflexio_env(api_key=api_key, reflexio_url=reflexio_url)
+        changed = ", ".join(added) if added else "managed Reflexio settings"
+        sys.stdout.write(
+            f"Configured {_REFLEXIO_ENV_PATH} for managed Reflexio "
+            f"({changed}; API key {env_config.mask_secret(api_key)}).\n"
+        )
+        return
+
+    added = _seed_reflexio_env()
+    if added:
+        sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
+
+
+def cmd_install_codex(args: argparse.Namespace) -> int:
     """Install the claude-smart plugin marketplace for Codex.
 
     Only supported from a source checkout — the wheel ships the Python
@@ -766,9 +808,7 @@ def cmd_install_codex(_args: argparse.Namespace) -> int:
         return 1
     marketplace_root = _prepare_codex_local_marketplace()
 
-    added = _seed_reflexio_env()
-    if added:
-        sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
+    _configure_reflexio_setup(args)
 
     hooks_ok, hooks_msg = _enable_codex_plugin_hooks()
     if hooks_ok:
@@ -870,9 +910,7 @@ def cmd_install(args: argparse.Namespace) -> int:
             sys.stderr.write(f"error: {' '.join(cmd)} failed (exit {exc.returncode})\n")
             return exc.returncode or 1
 
-    added = _seed_reflexio_env()
-    if added:
-        sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
+    _configure_reflexio_setup(args)
 
     bootstrapped, message = _bootstrap_claude_code_install()
     if not bootstrapped:
@@ -952,8 +990,7 @@ def cmd_uninstall(_args: argparse.Namespace) -> int:
 
     sys.stdout.write(
         "\nclaude-smart uninstalled. Restart Claude Code to apply.\n"
-        "Local data in ~/.reflexio/ and ~/.claude-smart/ was left in place — "
-        "remove manually if desired.\n"
+        f"{_LOCAL_DATA_NOTICE}"
     )
     return 0
 
@@ -990,8 +1027,8 @@ def cmd_uninstall_codex(_args: argparse.Namespace) -> int:
         sys.stderr.write(f"warning: could not update {_CODEX_CONFIG_PATH}\n")
     sys.stdout.write(
         "claude-smart Codex plugin and marketplace state removed. Restart Codex to apply. "
-        "Codex's global hook feature flags and local data under ~/.reflexio "
-        "and ~/.claude-smart were left in place.\n"
+        "Codex's global hook feature flags were left in place.\n"
+        f"{_LOCAL_DATA_NOTICE}"
     )
     return 0
 
@@ -1025,6 +1062,13 @@ def cmd_show(args: argparse.Namespace) -> int:
         agent_playbooks=agent_playbooks,
         profiles=profiles,
     )
+    if not md and adapter.read_errors:
+        sys.stdout.write(
+            "Could not read skills or preferences from Reflexio for "
+            f"project `{project_id}` at `{adapter.url}`.\n"
+            f"First error: {adapter.read_errors[0]}\n"
+        )
+        return 1
     sys.stdout.write(
         md or f"_No skills or preferences yet for project `{project_id}`._\n"
     )
@@ -1034,8 +1078,10 @@ def cmd_show(args: argparse.Namespace) -> int:
 def cmd_learn(args: argparse.Namespace) -> int:
     """Force reflexio extraction over the active session's interactions.
 
-    Publishes unpublished interactions with ``force_extraction=True`` so
-    extraction runs immediately rather than at the next batch interval.
+    Publishes unpublished interactions with ``force_extraction=True`` and
+    ``override_learning_stall=True`` as an explicit retry request rather than
+    waiting for the next batch interval. The publish call itself remains
+    non-blocking: ``Adapter.publish`` sends ``wait_for_response=False``.
     When ``args.note`` is provided, the note is appended to the session
     buffer as a neutral User turn before publishing — letting the user
     capture an explicit insight, preference, or workflow note alongside
@@ -1073,6 +1119,7 @@ def cmd_learn(args: argparse.Namespace) -> int:
         session_id=session_id,
         project_id=project_id,
         force_extraction=True,
+        override_learning_stall=True,
         skip_aggregation=False,
     )
     if status == "ok":
@@ -1561,6 +1608,113 @@ def cmd_clear_all(args: argparse.Namespace) -> int:
     return start_rc or 0
 
 
+def _resolve_reflexio_url() -> str:
+    """Return the URL endpoint for the local claude-smart reflexio backend.
+
+    Mirrors ``claude_smart.reflexio_adapter`` so the CLI's one-shot
+    ReflexioClient calls hit the same server as the long-lived adapter
+    used by hook handlers.
+
+    Returns:
+        str: The ``REFLEXIO_URL`` env var if set, otherwise the default
+            local backend endpoint.
+    """
+    env_config.load_reflexio_env()
+    return os.environ.get("REFLEXIO_URL", "http://localhost:8071/")
+
+
+def _resolve_reflexio_api_key() -> str:
+    env_config.load_reflexio_env()
+    return os.environ.get("REFLEXIO_API_KEY", "")
+
+
+def _format_deleted_counts(deleted_counts: object) -> str:
+    """Render ``deleted_counts`` from a ``clear_user_data`` response as a summary.
+
+    The backend returns one count per affected table. We surface the
+    total in the headline string (``"removed N row(s)"``) and append a
+    per-table breakdown when at least one bucket is populated, so the
+    operator can tell *what* got cleared at a glance.
+
+    Args:
+        deleted_counts (object): The ``deleted_counts`` field from the
+            backend response. Expected to be a mapping of
+            ``str -> int``; anything else is rendered as ``"unknown"``.
+
+    Returns:
+        str: A short human-readable summary suitable for echoing to
+            stdout (e.g. ``"3 row(s) (interactions=3)"``).
+    """
+    if not isinstance(deleted_counts, dict):
+        return "unknown row(s)"
+    pairs: list[tuple[str, int]] = []
+    for key, value in deleted_counts.items():
+        if isinstance(key, str) and isinstance(value, int):
+            pairs.append((key, value))
+    total = sum(value for _, value in pairs)
+    if not pairs:
+        return f"{total} row(s)"
+    breakdown = ", ".join(f"{name}={count}" for name, count in sorted(pairs))
+    return f"{total} row(s) ({breakdown})"
+
+
+def cmd_clear_user(args: argparse.Namespace) -> int:
+    """Delete one user_id's playbooks, profiles, and interactions via the backend.
+
+    Per-user-scoped counterpart of ``clear-all``. Where ``clear-all`` does
+    a filesystem-level wipe of the entire local storage root, ``clear-user``
+    routes through the running reflexio backend's ``clear_user_data``
+    endpoint so it can scope the deletion to a single ``user_id`` —
+    leaving other users' data and globally-shared ``agent_playbooks``
+    untouched. This is the primitive SWE-bench-style benchmark harnesses
+    need when running many parallel evaluations under distinct synthetic
+    user ids against one shared backend.
+
+    Args:
+        args (argparse.Namespace): Parsed CLI args. Requires
+            ``args.user_id`` (positional) and ``args.yes`` (the
+            destructive-action confirmation flag, matching ``clear-all``).
+
+    Returns:
+        int: 0 on success, 1 if confirmation is missing or the backend
+            call fails.
+    """
+    user_id = args.user_id
+    if not args.yes:
+        sys.stdout.write(
+            f"This will permanently delete all reflexio rows for user '{user_id}' "
+            "(playbooks, profiles, interactions). Other users' data and "
+            "agent_playbooks are not affected.\n"
+            "Re-run with --yes to confirm.\n"
+        )
+        return 1
+
+    try:
+        from reflexio import ReflexioClient  # type: ignore[import-not-found]
+    except ImportError as exc:
+        sys.stderr.write(f"error: reflexio is not installed: {exc}\n")
+        return 1
+
+    try:
+        client = ReflexioClient(
+            url_endpoint=_resolve_reflexio_url(),
+            api_key=_resolve_reflexio_api_key(),
+        )
+        # The companion reflexio PR adds ``clear_user_data``; keep the
+        # CLI buildable until both sides ship together.
+        response = client.clear_user_data(user_id)  # pyright: ignore[reportAttributeAccessIssue]
+    except Exception as exc:  # noqa: BLE001 — surface backend failure verbatim.
+        sys.stderr.write(f"error: clear-user failed: {exc}\n")
+        return 1
+
+    deleted_counts = (
+        response.get("deleted_counts") if isinstance(response, dict) else None
+    )
+    summary = _format_deleted_counts(deleted_counts)
+    sys.stdout.write(f"Cleared user '{user_id}': removed {summary}.\n")
+    return 0
+
+
 def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="claude-smart")
     sub = parser.add_subparsers(dest="command", required=True)
@@ -1577,6 +1731,16 @@ def _build_parser() -> argparse.ArgumentParser:
         default=_DEFAULT_MARKETPLACE_SOURCE,
         help="Marketplace ref — GitHub owner/repo, or a local directory path",
     )
+    inst.add_argument(
+        "--api-key",
+        default="",
+        help="Configure managed Reflexio with this API key instead of local mode",
+    )
+    inst.add_argument(
+        "--reflexio-url",
+        default=_MANAGED_REFLEXIO_URL,
+        help="Managed Reflexio URL used only when --api-key is provided",
+    )
     inst.set_defaults(func=cmd_install)
 
     upd = sub.add_parser("update", help="Update claude-smart to the latest version")
@@ -1625,6 +1789,25 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     ca.set_defaults(func=cmd_clear_all)
 
+    cu = sub.add_parser(
+        "clear-user",
+        help=(
+            "Delete one user_id's playbooks, profiles, and interactions via "
+            "the backend (leaves other users and agent_playbooks intact)"
+        ),
+    )
+    cu.add_argument(
+        "user_id",
+        help="User id whose reflexio rows should be cleared",
+    )
+    cu.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help="Confirm the destructive clear without prompting",
+    )
+    cu.set_defaults(func=cmd_clear_user)
+
     rs = sub.add_parser(
         "restart",
         help="Restart the reflexio backend and dashboard to pick up changes",
@@ -1649,6 +1832,7 @@ def _build_parser() -> argparse.ArgumentParser:
 
 
 def main(argv: list[str] | None = None) -> int:
+    env_config.load_reflexio_env()
     parser = _build_parser()
     args = parser.parse_args(argv)
     return args.func(args)