claude-smart 0.2.44 → 0.2.46

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/events/before_prompt_build.py

@@ -0,0 +1,69 @@
+"""before_prompt_build hook — buffer the user turn and inject matching context.
+
+Two responsibilities, in order:
+
+1. Buffer the prompt into the session JSONL (this is the sole source of
+   ``"User"`` role turns downstream — openClaw replays the rest of the
+   transcript via tool events, not before_prompt_build).
+2. Use the prompt text as a search query against reflexio's preferences +
+   skills and emit the top hits as ``prependContext`` so the model sees
+   relevant rules before planning the response.
+
+The shared pipeline lives in ``context_inject.emit_context``. Retrieval is
+best-effort: any failure from search (reflexio unreachable, HTTP timeout,
+unexpected shape) is caught so the buffered-prompt behaviour is always
+preserved.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from openclaw_smart import context_inject, ids, state
+
+_LOGGER = logging.getLogger(__name__)
+_TOP_K = 3
+
+
+def handle(payload: dict[str, Any]) -> None:
+    """before_prompt_build dispatcher — buffers the prompt, then injects context.
+
+    Args:
+        payload (dict[str, Any]): The openClaw event/ctx blob (merged). Expected
+            keys ``sessionKey`` (or ``sessionId``), ``prompt``, optionally
+            ``agentId`` and ``workspaceDir``.
+
+    Returns:
+        None: Side effects only — appends to the session buffer and may
+            write a ``{"prependContext": ...}`` JSON document to stdout.
+    """
+    session_id = payload.get("sessionKey") or payload.get("sessionId")
+    prompt = payload.get("prompt") or ""
+    if not session_id or not prompt:
+        return
+
+    project_id = ids.resolve_project_id_with_fallback(
+        cwd=payload.get("workspaceDir"),
+        agent_id=payload.get("agentId"),
+    )
+    state.append(
+        session_id,
+        {
+            "ts": int(time.time()),
+            "role": "User",
+            "content": prompt,
+            "user_id": project_id,
+        },
+    )
+
+    try:
+        context_inject.emit_context(
+            session_id=session_id,
+            project_id=project_id,
+            query=prompt,
+            top_k=_TOP_K,
+        )
+    except Exception as exc:  # noqa: BLE001 — never break the user's turn
+        _LOGGER.debug("before_prompt_build context inject failed: %s", exc)

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/events/before_tool_call.py

@@ -0,0 +1,30 @@
+"""before_tool_call hook — observe-only stub.
+
+Phase 0 probe finding Q1: openClaw's ``before_tool_call`` hook does NOT
+honor ``prependContext`` returned by plugins, so injecting context here
+would have no effect on the upcoming tool call. (In contrast, Claude
+Code's PreToolUse hook is the primary just-in-time injection point.)
+
+This handler is therefore a silent no-op in v1. The TS shim may choose
+not to register it at all — having a stub here keeps the dispatcher
+symmetric and leaves room for future observe-only telemetry.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def handle(payload: dict[str, Any]) -> None:
+    """before_tool_call dispatcher — silent no-op.
+
+    Args:
+        payload (dict[str, Any]): Unused. openClaw delivers
+            ``{toolName, params, sessionKey, agentId}`` here but we have no
+            actionable side effect to apply per Phase 0 finding Q1.
+    """
+    del payload
+    _LOGGER.debug("before_tool_call invoked (observe-only stub)")

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/events/session_end.py

@@ -0,0 +1,36 @@
+"""session_end hook — flush any remaining interactions with forced extraction.
+
+Fires when an openClaw session terminates. We force extraction here (unlike
+``agent_end``, which lets reflexio queue extraction for its next sweep) so
+the user's distilled lessons from this session are usable in the very next
+session, not after the next scheduled sweep.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from openclaw_smart import ids, publish
+
+
+def handle(payload: dict[str, Any]) -> None:
+    """Drain the buffer and trigger synchronous extraction.
+
+    Args:
+        payload (dict[str, Any]): openClaw event/ctx blob, expected to
+            contain ``sessionKey`` (or ``sessionId``) and optionally
+            ``agentId`` / ``workspaceDir``.
+    """
+    session_id = payload.get("sessionKey") or payload.get("sessionId")
+    if not session_id:
+        return
+    project_id = ids.resolve_project_id_with_fallback(
+        cwd=payload.get("workspaceDir"),
+        agent_id=payload.get("agentId"),
+    )
+    publish.publish_unpublished(
+        session_id=session_id,
+        project_id=project_id,
+        force_extraction=True,
+        skip_aggregation=False,
+    )

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/events/session_start.py

@@ -0,0 +1,130 @@
+"""session_start hook — apply startup defaults without broad memory retrieval.
+
+For openClaw, the ``session_start`` event delivers ``{sessionId, sessionKey,
+agentId, workspaceDir}``. The handler:
+
+1. Fetches the current stall state from reflexio and renders a 1-line banner
+   to ``prependContext`` if learning is paused.
+2. Pushes openclaw-smart's preferred extraction defaults (smaller window /
+   stride than reflexio's out-of-box 10/5).
+3. Pushes optimizer defaults so reflexio can evaluate candidate playbooks
+   via the local ``openclaw infer model run`` CLI.
+
+Output: when there is a banner, emits ``{"prependContext": "<banner>"}`` on
+stdout for the TS shim to relay back to openClaw. Otherwise emits nothing.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from openclaw_smart.reflexio_adapter import Adapter
+from openclaw_smart.stall_banner import render_banner
+
+# openclaw-smart's preferred extraction cadence — more frequent, smaller
+# windows than reflexio's out-of-box 10/5. Applied idempotently to the
+# reflexio server on every session_start via
+# Adapter.apply_extraction_defaults.
+_WINDOW_SIZE = 5
+_STRIDE_SIZE = 3
+# Optimizer is on by default. Set this env var to "0" to skip pushing the
+# openclaw-smart optimizer defaults on session_start (kill switch).
+_DISABLE_OPTIMIZER_ENV = "OPENCLAW_SMART_ENABLE_OPTIMIZER"
+_OPTIMIZER_TIMEOUT_SECONDS = 300
+
+
+def _adapter() -> Adapter:
+    """Construct the reflexio adapter for this hook invocation.
+
+    Indirected through a factory so tests can monkeypatch the adapter
+    construction without touching the ``Adapter`` class itself.
+
+    Returns:
+        Adapter: A fresh adapter bound to the current process env.
+    """
+    return Adapter()
+
+
+def _stall_banner(adapter: Any) -> str:
+    """Return the prepend-able stall banner, or "" if no banner should fire.
+
+    Reads ``adapter.fetch_stall_state()``; if it reports an active,
+    not-yet-notified stall, renders a one-line banner via
+    ``stall_banner.render_banner``. All exceptions are absorbed: this is
+    defense-in-depth — even though the hook dispatcher already wraps
+    ``handle`` in try/except, a stall-path bug must never block the
+    existing playbook/profile rendering.
+
+    Args:
+        adapter (Any): The adapter to query. Duck-typed so tests can stub.
+
+    Returns:
+        str: The banner text, or ``""`` when there is nothing to show.
+    """
+    try:
+        state_obj = adapter.fetch_stall_state()
+    except Exception:  # noqa: BLE001 — stall path must never crash the hook.
+        return ""
+    if state_obj is None:
+        return ""
+    if not getattr(state_obj, "stalled", False):
+        return ""
+    if getattr(state_obj, "notified_in_cc", False):
+        return ""
+    try:
+        return render_banner(
+            reason=getattr(state_obj, "reason", None),
+            reset_estimate=getattr(state_obj, "reset_estimate", None),
+        )
+    except Exception:  # noqa: BLE001 — render_banner bug must not block playbook injection.
+        return ""
+
+
+def handle(payload: dict[str, Any]) -> None:
+    """Handle a session_start hook payload.
+
+    Args:
+        payload (dict[str, Any]): openClaw event/ctx blob, expected to
+            contain ``sessionKey`` (or ``sessionId``).
+    """
+    session_id = payload.get("sessionKey") or payload.get("sessionId")
+    if not session_id:
+        return
+
+    adapter = _adapter()
+
+    # Stall banner — emitted via prependContext, fires at most once per stall
+    # event (controlled server-side via mark_stall_notified).
+    banner = _stall_banner(adapter)
+
+    adapter.apply_extraction_defaults(
+        window_size=_WINDOW_SIZE,
+        stride_size=_STRIDE_SIZE,
+    )
+    if os.environ.get(_DISABLE_OPTIMIZER_ENV) != "0":
+        adapter.apply_optimizer_defaults(
+            script_path=_optimizer_assistant_path(),
+            timeout_seconds=_OPTIMIZER_TIMEOUT_SECONDS,
+        )
+
+    if not banner:
+        return
+
+    sys.stdout.write(json.dumps({"prependContext": banner}))
+    sys.stdout.write("\n")
+
+    # Telemetry must not break the session.
+    with contextlib.suppress(Exception):
+        adapter.mark_stall_notified()
+
+
+def _optimizer_assistant_path() -> str:
+    """Return the absolute path to the openclaw-smart-optimizer-assistant binary."""
+    executable = Path(sys.executable)
+    suffix = ".exe" if os.name == "nt" else ""
+    return str(executable.with_name(f"openclaw-smart-optimizer-assistant{suffix}"))

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/hook.py

@@ -0,0 +1,131 @@
+"""Dispatch table for openclaw-smart hook events.
+
+The TS shim spawns ``python -m openclaw_smart.hook <event>`` (or the
+``openclaw-smart-hook`` console script) once per hook invocation, piping
+the openClaw event payload on stdin. This module reads the JSON, routes
+to the matching handler, and makes sure no unhandled exception ever
+propagates back to openClaw.
+
+Handlers emit their own ``{"prependContext": …}`` JSON to stdout when
+they have context to inject; otherwise they emit nothing. The dispatcher
+emits nothing on no-op paths (unknown event, recursion guard, handler
+exception) so the TS shim can treat empty stdout as "no return value".
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from collections.abc import Callable
+from typing import Any
+
+from openclaw_smart import runtime
+from openclaw_smart.internal_call import is_internal_invocation
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _load_handlers() -> dict[str, Callable[[dict[str, Any]], None]]:
+    """Import handler modules lazily to keep cold-start cost low."""
+    from openclaw_smart.events import (
+        after_tool_call,
+        agent_end,
+        before_prompt_build,
+        before_tool_call,
+        session_end,
+        session_start,
+    )
+
+    return {
+        "session-start": session_start.handle,
+        "before-prompt-build": before_prompt_build.handle,
+        "before-tool-call": before_tool_call.handle,
+        "after-tool-call": after_tool_call.handle,
+        "agent-end": agent_end.handle,
+        "session-end": session_end.handle,
+    }
+
+
+_HANDLERS: dict[str, Callable[[dict[str, Any]], None]] | None = None
+
+
+def _handlers() -> dict[str, Callable[[dict[str, Any]], None]]:
+    global _HANDLERS
+    if _HANDLERS is None:
+        _HANDLERS = _load_handlers()
+    return _HANDLERS
+
+
+def _read_stdin_json() -> dict[str, Any]:
+    """Parse stdin as JSON. Returns ``{}`` on empty or malformed input."""
+    try:
+        raw = sys.stdin.read()
+    except (OSError, ValueError) as exc:
+        _LOGGER.debug("stdin read failed: %s", exc)
+        return {}
+    if not raw.strip():
+        return {}
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        _LOGGER.debug("stdin JSON decode failed: %s", exc)
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _parse_args(argv: list[str]) -> str:
+    """Return the event name from ``argv``.
+
+    Accepts either ``[event]`` or ``[host, event]`` for symmetry with
+    claude-smart, but the host arg (if present) must be ``"openclaw"`` and
+    is otherwise ignored — runtime.set_host is called either way.
+    """
+    if not argv:
+        return ""
+    if len(argv) >= 2 and argv[0] in runtime.VALID_HOSTS:
+        return argv[1]
+    return argv[0]
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point used by ``python -m openclaw_smart.hook`` and the console script.
+
+    Args:
+        argv (list[str] | None): Command-line args (sans program name).
+            Defaults to ``sys.argv[1:]``.
+
+    Returns:
+        int: Always 0 — failures are absorbed so the host never sees a
+            non-zero exit and decides to surface a plugin error.
+    """
+    argv = argv if argv is not None else sys.argv[1:]
+    event = _parse_args(argv)
+    runtime.set_host(runtime.HOST_OPENCLAW)
+    if not event:
+        _LOGGER.warning("hook dispatcher called with no event name")
+        return 0
+
+    payload = _read_stdin_json()
+
+    # Self-feedback guard: when this hook fires inside reflexio's own
+    # openclaw subprocess (the openclaw LLM provider), skip all handlers
+    # so we don't publish the extractor's system prompt back into reflexio.
+    # See openclaw_smart.internal_call for detection logic.
+    if is_internal_invocation(payload):
+        return 0
+
+    handler = _handlers().get(event)
+    if handler is None:
+        _LOGGER.warning("unknown hook event: %s", event)
+        return 0
+
+    try:
+        handler(payload)
+    except Exception as exc:  # noqa: BLE001 — hooks must never crash the session.
+        _LOGGER.exception("hook handler %s raised: %s", event, exc)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/ids.py

@@ -0,0 +1,94 @@
+"""Resolve stable identifiers for openClaw sessions.
+
+Two identifiers matter to reflexio:
+
+- ``session_id``: openClaw's per-session id (``sessionKey``), passed via the
+  TS shim. We forward it to reflexio's interaction ``session_id`` field so
+  individual turns remain attributable to their conversation, but it is no
+  longer the scope key for extracted preferences.
+- ``project_id``: a stable, cross-session name for the project. We use this
+  as reflexio's ``user_id`` for preferences, so user preferences extracted
+  in one session are visible to every later session in the same repo.
+  ``agent_version`` is hardcoded to ``"openclaw"`` in the adapter so shared
+  skills roll up globally across all openclaw projects.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess  # noqa: S404 — git invocation with a fixed flag set.
+from pathlib import Path
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _resolve_from_git(cwd: Path) -> str | None:
+    """Return the git toplevel basename for *cwd*, or ``None`` if not a repo.
+
+    Must never raise — callers depend on this returning ``None`` cleanly so
+    hook handlers can fall back to other identifiers. Resolves ``git`` to an
+    absolute path first to avoid PATH-dependent process spawning, and catches
+    any ``OSError`` (e.g., ``cwd`` is unreadable or has been deleted) along
+    with the previously-handled ``FileNotFoundError`` / ``TimeoutExpired``.
+    """
+    git_bin = shutil.which("git")
+    if not git_bin:
+        return None
+    try:
+        result = subprocess.run(  # noqa: S603 — fixed argv, cwd is a Path.
+            [git_bin, "rev-parse", "--show-toplevel"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            toplevel = result.stdout.strip()
+            if toplevel:
+                return Path(toplevel).name
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        # OSError covers FileNotFoundError + PermissionError + missing-cwd.
+        _LOGGER.debug("git toplevel resolution failed: %s", exc)
+    return None
+
+
+def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
+    """Return a stable project identifier for the given working directory.
+
+    Prefers the basename of the git toplevel (so worktrees, submodules, and
+    ``cd src/`` all still map to the same project). Falls back to the cwd
+    basename when the directory is not inside a git repo.
+
+    Args:
+        cwd: Working directory to resolve. Defaults to ``os.getcwd()``.
+
+    Returns:
+        str: A non-empty identifier. Never raises.
+    """
+    base = Path(cwd) if cwd is not None else Path.cwd()
+    return _resolve_from_git(base) or base.name or "unknown-project"
+
+
+def resolve_project_id_with_fallback(
+    cwd: str | os.PathLike[str] | None,
+    agent_id: str | None,
+) -> str:
+    """Resolve project ID, falling back to ``agent_id`` when not in a git repo.
+
+    openClaw can run from any directory (or none at all), so when there is no
+    git context we prefer the openClaw agent id over a fabricated cwd
+    basename, which would be brittle across sessions.
+
+    Args:
+        cwd: Working directory of the openClaw session (``ctx.workspaceDir``).
+        agent_id: openClaw agent id from ``ctx.agentId``.
+
+    Returns:
+        str: git repo basename if cwd is in a repo; else ``agent_id``; else
+        the literal ``"openclaw"``.
+    """
+    base = Path(cwd) if cwd is not None else Path.cwd()
+    return _resolve_from_git(base) or agent_id or "openclaw"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/internal_call.py

@@ -0,0 +1,75 @@
+"""Detect hook invocations that should not be published to reflexio.
+
+The single concern for openclaw-smart is reflexio's own LLM provider. The
+``openclaw`` LiteLLM provider (see
+``reflexio.server.llm.providers.openclaw_provider``) shells out to the
+``openclaw`` CLI to answer extractor prompts. That subprocess is a full
+openClaw invocation, so it fires *our* hooks too — and without a guard,
+the ``agent_end`` hook would publish the extractor's own system prompt
+back into reflexio as a user interaction. Reflexio would then train on
+its own internals.
+
+Detection signals, OR'd:
+  - Env var ``OPENCLAW_SMART_INTERNAL=1``, set by reflexio's provider
+    before spawning ``openclaw``.
+  - ``payload.cwd`` resolves inside the reflexio repository. Catches
+    direct interactive ``openclaw`` runs from inside the reflexio
+    checkout (manual debugging) that would otherwise pollute the corpus.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+INTERNAL_ENV = "OPENCLAW_SMART_INTERNAL"
+
+# Plugin layout (in-repo / editable):
+#   <reflexio_repo>/reflexio/integrations/openclaw/plugin/src/openclaw_smart/internal_call.py
+# parents[5] = <reflexio_repo>, the directory we want to fence off.
+#
+# In install-mode layouts (PyPI wheel, ~/.openclaw/plugins/cache/...), this
+# fixed depth doesn't hold. Guarding the index lookup keeps module import
+# from crashing on unfamiliar layouts — the env marker is the primary
+# signal there. ``OPENCLAW_SMART_REFLEXIO_DIR`` lets callers (and tests)
+# override the path without touching the module.
+_THIS_DIR = Path(__file__).resolve().parent
+_override_reflexio_dir = os.environ.get("OPENCLAW_SMART_REFLEXIO_DIR")
+if _override_reflexio_dir:
+    _REFLEXIO_DIR: Path = Path(_override_reflexio_dir).resolve()
+else:
+    _parents = _THIS_DIR.parents
+    # In an unexpected layout we fall back to _THIS_DIR itself, which makes
+    # the relative_to() check below match (correctly) only when cwd is
+    # literally inside this module's own directory — effectively a no-op
+    # fence, ceding all detection responsibility to the env marker.
+    _REFLEXIO_DIR = _parents[5] if len(_parents) > 5 else _THIS_DIR
+
+
+def is_internal_invocation(payload: dict[str, Any]) -> bool:
+    """True if this hook fire originated from reflexio's own LLM provider.
+
+    Args:
+        payload (dict[str, Any]): Parsed openClaw hook payload. Only ``cwd``
+            (or ``workspaceDir``) is inspected.
+
+    Returns:
+        bool: True when the env marker is set or ``cwd`` points inside the
+            reflexio repository. False otherwise, including when ``cwd`` is
+            missing or unresolvable.
+    """
+    if os.environ.get(INTERNAL_ENV) == "1":
+        return True
+    cwd = payload.get("cwd") or payload.get("workspaceDir")
+    if not isinstance(cwd, str) or not cwd:
+        return False
+    try:
+        resolved = Path(cwd).resolve()
+    except OSError:
+        return False
+    try:
+        resolved.relative_to(_REFLEXIO_DIR)
+    except ValueError:
+        return False
+    return True