claude-smart 0.2.44 → 0.2.46

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

@@ -0,0 +1,224 @@
+"""Render reflexio preferences + skills as markdown for display or injection."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+from openclaw_smart import oc_cite
+
+
+def _first_nonempty(*values: Any) -> str:
+    """Return the first truthy string value, or an empty string."""
+    for v in values:
+        if isinstance(v, str) and v.strip():
+            return v.strip()
+    return ""
+
+
+def render(
+    *,
+    project_id: str,
+    user_playbooks: Iterable[Any],
+    agent_playbooks: Iterable[Any],
+    profiles: Iterable[Any],
+) -> str:
+    """Render skills + preferences as full audit markdown.
+
+    Empty sections are omitted. When all sections are empty, returns "".
+    """
+    markdown, _ = render_with_registry(
+        project_id=project_id,
+        user_playbooks=user_playbooks,
+        agent_playbooks=agent_playbooks,
+        profiles=profiles,
+    )
+    return markdown
+
+
+def render_with_registry(
+    *,
+    project_id: str,
+    user_playbooks: Iterable[Any],
+    agent_playbooks: Iterable[Any],
+    profiles: Iterable[Any],
+) -> tuple[str, list[dict[str, Any]]]:
+    """Variant of ``render`` that also returns the citation registry.
+
+    Every skill and preference bullet is tagged with a short ``[oc:ID]``
+    prefix. The registry maps those ids back to ``{id, kind, title,
+    content}`` entries so ``events.agent_end`` can resolve citations into
+    human-readable titles for the dashboard.
+
+    Agent playbooks (cross-project, distilled) are listed before user
+    playbooks (this project's lessons) under one ``### Project-specific
+    skills`` heading. The model doesn't need to reason about the split.
+    """
+    playbook_lines, playbook_entries = _format_combined_playbooks(
+        agent_playbooks=agent_playbooks, user_playbooks=user_playbooks
+    )
+    profile_lines, profile_entries = _format_profiles(profiles)
+    if not playbook_lines and not profile_lines:
+        return "", []
+
+    sections: list[str] = [f"## openclaw-smart — project `{project_id}`"]
+    if playbook_lines:
+        sections.append("### Project-specific skills")
+        sections.extend(playbook_lines)
+    if profile_lines:
+        sections.append("### Project preferences")
+        sections.extend(profile_lines)
+    sections.append(oc_cite.CITATION_INSTRUCTION)
+    return "\n".join(sections) + "\n", playbook_entries + profile_entries
+
+
+def render_inline(
+    *,
+    project_id: str,
+    user_playbooks: Iterable[Any],
+    agent_playbooks: Iterable[Any],
+    profiles: Iterable[Any],
+) -> str:
+    """Render skills + preferences for mid-session injection.
+
+    Same bullet format as ``render`` but with no top-level project header.
+    This block is injected just-in-time alongside an in-flight user prompt or
+    tool call, so the caller already has project context.
+    """
+    markdown, _ = render_inline_with_registry(
+        project_id=project_id,
+        user_playbooks=user_playbooks,
+        agent_playbooks=agent_playbooks,
+        profiles=profiles,
+    )
+    return markdown
+
+
+def render_inline_with_registry(
+    *,
+    project_id: str,
+    user_playbooks: Iterable[Any],
+    agent_playbooks: Iterable[Any],
+    profiles: Iterable[Any],
+) -> tuple[str, list[dict[str, Any]]]:
+    """Variant of ``render_inline`` that also returns the citation registry."""
+    del project_id  # kept for symmetry with ``render_with_registry``.
+    playbook_lines, playbook_entries = _format_combined_playbooks(
+        agent_playbooks=agent_playbooks, user_playbooks=user_playbooks
+    )
+    profile_lines, profile_entries = _format_profiles(profiles)
+    if not playbook_lines and not profile_lines:
+        return "", []
+    sections: list[str] = []
+    if playbook_lines:
+        sections.append("### Relevant project-specific skills")
+        sections.extend(playbook_lines)
+    if profile_lines:
+        sections.append("### Relevant project preferences")
+        sections.extend(profile_lines)
+    sections.append(oc_cite.CITATION_INSTRUCTION)
+    return "\n".join(sections) + "\n", playbook_entries + profile_entries
+
+
+def _format_combined_playbooks(
+    *,
+    agent_playbooks: Iterable[Any],
+    user_playbooks: Iterable[Any],
+) -> tuple[list[str], list[dict[str, Any]]]:
+    """Render agent playbooks first, then user playbooks, with one shared rank counter."""
+    lines: list[str] = []
+    entries: list[dict[str, Any]] = []
+    rank = 0
+    for pb in agent_playbooks:
+        rank = _append_playbook_bullet(
+            pb, "agent_playbook_id", "agent_playbook", rank, lines, entries
+        )
+    for pb in user_playbooks:
+        rank = _append_playbook_bullet(
+            pb, "user_playbook_id", "user_playbook", rank, lines, entries
+        )
+    return lines, entries
+
+
+def _append_playbook_bullet(
+    pb: Any,
+    id_field: str,
+    source_kind: str,
+    rank: int,
+    lines: list[str],
+    entries: list[dict[str, Any]],
+) -> int:
+    content = _first_nonempty(_field(pb, "content"))
+    if not content:
+        return rank
+    rank += 1
+    trigger = _first_nonempty(_field(pb, "trigger"))
+    rationale = _first_nonempty(_field(pb, "rationale"))
+    real_id = _field(pb, id_field)
+    item_id = oc_cite.rank_id("playbook", rank, real_id)
+    title = _title_from_content(content)
+    bullet = f"- [oc:{item_id}] {content}"
+    if trigger:
+        bullet += f" _(when: {trigger})_"
+    if rationale:
+        bullet += f" — *why:* {rationale}"
+    lines.append(bullet)
+    entries.append(
+        {
+            "id": item_id,
+            "kind": "playbook",
+            "title": title,
+            "content": content,
+            "real_id": str(real_id) if real_id is not None else None,
+            "source_kind": source_kind,
+        }
+    )
+    return rank
+
+
+def _format_profiles(
+    profiles: Iterable[Any],
+) -> tuple[list[str], list[dict[str, Any]]]:
+    lines: list[str] = []
+    entries: list[dict[str, Any]] = []
+    rank = 0
+    for p in profiles:
+        content = _first_nonempty(_field(p, "content"))
+        if not content:
+            continue
+        rank += 1
+        real_id = _field(p, "profile_id")
+        item_id = oc_cite.rank_id("profile", rank, real_id)
+        title = _title_from_content(content)
+        lines.append(f"- [oc:{item_id}] {content}")
+        entries.append(
+            {
+                "id": item_id,
+                "kind": "profile",
+                "title": title,
+                "content": content,
+                "real_id": str(real_id) if real_id is not None else None,
+            }
+        )
+    return lines, entries
+
+
+def _title_from_content(content: str, limit: int = 80) -> str:
+    """Derive a compact human-readable title from a bullet's content."""
+    text = content.strip()
+    if not text:
+        return ""
+    for terminator in (". ", "\n"):
+        idx = text.find(terminator)
+        if 0 < idx <= limit:
+            return text[:idx].rstrip()
+    if len(text) <= limit:
+        return text
+    return text[: limit - 1].rstrip() + "…"
+
+
+def _field(obj: Any, name: str) -> Any:
+    """Read ``name`` from either an attribute or a dict key."""
+    if isinstance(obj, dict):
+        return obj.get(name)
+    return getattr(obj, name, None)

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

@@ -0,0 +1,79 @@
+"""Shared "search reflexio, render markdown, emit envelope" pipeline.
+
+before_tool_call and before_prompt_build both (a) run a query-aware reflexio
+search, (b) render the hits with ``context_format.render_inline_with_registry``,
+(c) persist the citation registry for the agent_end hook to resolve, and
+(d) emit a ``prependContext`` envelope on stdout. The TS shim wraps stdout
+and translates it to the openClaw plugin-SDK return shape.
+
+Per Phase 0 finding B2 we use ``prependContext`` (per-turn) rather than
+``prependSystemContext`` (cached) so injected context refreshes every turn.
+``before_tool_call`` is observe-only per finding Q1, so handlers there
+should NOT call ``emit_context`` — they only append state.
+
+The caller remains responsible for handler-specific framing — see the two
+call sites for the small policy differences.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+
+from openclaw_smart import context_format, oc_cite, state
+from openclaw_smart.reflexio_adapter import Adapter
+
+
+def emit_context(
+    *,
+    session_id: str,
+    project_id: str,
+    query: str,
+    top_k: int,
+    adapter: Adapter | None = None,
+) -> bool:
+    """Search reflexio, render hits, emit ``prependContext`` JSON on stdout.
+
+    Args:
+        session_id (str): openClaw session id (``sessionKey``); used to scope
+            the per-session citation registry.
+        project_id (str): reflexio ``user_id`` for this repo.
+        query (str): Free-text query routed to reflexio's unified
+            ``/api/search`` endpoint, which fans out to user playbooks
+            (project-scoped), agent playbooks (global), and preferences
+            (project-scoped) server-side.
+        top_k (int): Cap on hits per collection.
+        adapter (Adapter | None): Injection seam for tests. A fresh
+            ``Adapter()`` is used when ``None``.
+
+    Returns:
+        bool: ``True`` when markdown was emitted to stdout; ``False`` when
+            the search returned nothing to inject.
+    """
+    user_playbooks, agent_playbooks, profiles = (adapter or Adapter()).search_all(
+        project_id=project_id,
+        query=query,
+        top_k=top_k,
+    )
+    markdown, registry = context_format.render_inline_with_registry(
+        project_id=project_id,
+        user_playbooks=user_playbooks,
+        agent_playbooks=agent_playbooks,
+        profiles=profiles,
+    )
+    if not markdown:
+        return False
+
+    oc_cite.ensure_installed()
+    state.append_injected(
+        session_id,
+        (dict(entry, ts=int(time.time())) for entry in registry),
+    )
+
+    sys.stdout.write(json.dumps({"prependContext": markdown}))
+    sys.stdout.write("\n")
+    return True
+
+
+__all__ = ["emit_context"]

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

@@ -0,0 +1,160 @@
+"""after_tool_call hook — record the tool invocation and its outcome.
+
+openClaw delivers ``after_tool_call`` payloads with camelCase fields
+(``toolName``, ``params``, ``result``). Per Phase 0 finding B1 the handler
+translates these to snake_case before persisting so downstream consumers
+(state buffer, reflexio API) see a stable shape.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from typing import Any
+
+from openclaw_smart import state
+
+# Tool inputs are persisted locally and later published to reflexio, so we
+# apply a conservative redaction pass at ingestion time. Chosen to avoid
+# false positives over maximal coverage — the dashboard shows these
+# verbatim, and users noticing a masked command is far less surprising
+# than a masked ``LOG_LEVEL=INFO``.
+_MAX_STR_LEN = 4096
+_SECRET_ASSIGNMENT = re.compile(
+    r"(?P<key>[A-Z][A-Z0-9_]{2,})=(?P<quote>['\"]?)"
+    r"(?P<value>[A-Za-z0-9+/=_\-]{20,})(?P=quote)"
+)
+
+
+def _looks_like_secret(value: str) -> bool:
+    """Heuristic: mixed-case letters plus digits suggest a high-entropy token."""
+    has_lower = any(c.islower() for c in value)
+    has_upper = any(c.isupper() for c in value)
+    has_digit = any(c.isdigit() for c in value)
+    return has_lower and has_upper and has_digit
+
+
+def _mask_secrets(text: str) -> str:
+    """Mask values that look like high-entropy secrets in ``KEY=value`` form."""
+
+    def sub(match: re.Match[str]) -> str:
+        value = match.group("value")
+        if not _looks_like_secret(value):
+            return match.group(0)
+        key = match.group("key")
+        quote = match.group("quote")
+        return f"{key}={quote}<redacted:{len(value)}>{quote}"
+
+    return _SECRET_ASSIGNMENT.sub(sub, text)
+
+
+def _redact_string(value: str) -> str:
+    """Mask secrets in ``value`` then truncate to ``_MAX_STR_LEN`` chars."""
+    masked = _mask_secrets(value)
+    if len(masked) > _MAX_STR_LEN:
+        return masked[:_MAX_STR_LEN] + "…(truncated)"
+    return masked
+
+
+def _redact(tool_input: dict[str, Any]) -> dict[str, Any]:
+    """Redact obvious secrets and truncate oversized string values."""
+    return {
+        k: _redact_string(v) if isinstance(v, str) else v for k, v in tool_input.items()
+    }
+
+
+def _derive_status(tool_response: Any) -> str:
+    """Classify the tool outcome as 'success' or 'error'.
+
+    openClaw's ``after_tool_call`` payload places the tool result under
+    ``result``; a structured failure may use ``is_error``/``error`` keys,
+    while plain string results default to success.
+    """
+    if isinstance(tool_response, dict) and (
+        tool_response.get("is_error") or tool_response.get("error")
+    ):
+        return "error"
+    return "success"
+
+
+_OUTPUT_TEXT_KEYS = ("stdout", "stderr", "output", "content", "text", "error")
+
+
+def _flatten_tool_response_text(tool_response: Any) -> str:
+    """Flatten ``tool_response`` into a single string for buffering.
+
+    Tool responses arrive in heterogeneous shapes — Bash sends a dict with
+    ``stdout``/``stderr``, Edit/Read send a string or a dict with
+    ``content``/``output``, and failures populate ``error``. Joining the
+    well-known string-valued keys preserves the parts most useful for
+    downstream learning (failure messages, command output) without
+    serializing entire structured payloads.
+    """
+    if tool_response is None:
+        return ""
+    if isinstance(tool_response, str):
+        return tool_response
+    if isinstance(tool_response, dict):
+        parts = [
+            tool_response[key]
+            for key in _OUTPUT_TEXT_KEYS
+            if isinstance(tool_response.get(key), str) and tool_response[key]
+        ]
+        if parts:
+            return "\n".join(parts)
+        for key in ("text", "content"):
+            value = tool_response.get(key)
+            if isinstance(value, str):
+                return value
+        return ""
+    for attr in ("text", "content"):
+        value = getattr(tool_response, attr, None)
+        if isinstance(value, str):
+            return value
+    return ""
+
+
+def _extract_fields(payload: dict[str, Any]) -> dict[str, Any]:
+    """Map openClaw's camelCase keys onto our snake_case schema.
+
+    Accepts either style so the handler is resilient to dispatcher changes —
+    if a future TS shim emits already-translated keys, the snake_case
+    branch wins.
+    """
+    return {
+        "session_id": payload.get("sessionKey") or payload.get("sessionId"),
+        "tool_name": payload.get("tool_name") or payload.get("toolName") or "",
+        "tool_input": payload.get("tool_input") or payload.get("params") or {},
+        "tool_response": payload.get("tool_response")
+        if "tool_response" in payload
+        else payload.get("result"),
+    }
+
+
+def handle(payload: dict[str, Any]) -> None:
+    """Persist one tool invocation to the session JSONL buffer."""
+    fields = _extract_fields(payload)
+    session_id = fields["session_id"]
+    tool_name = fields["tool_name"]
+    if not session_id or not tool_name:
+        return
+
+    tool_response = fields["tool_response"]
+    output_text = _flatten_tool_response_text(tool_response)
+    # ``_redact`` expects a dict; non-dict payloads (raw string, list, or None)
+    # are wrapped under ``_raw`` so the redaction path stays uniform without
+    # crashing on the unusual shape.
+    raw_tool_input = fields["tool_input"]
+    if isinstance(raw_tool_input, dict):
+        safe_tool_input: dict[str, Any] = _redact(raw_tool_input)
+    else:
+        safe_tool_input = {"_raw": _redact_string(str(raw_tool_input))}
+    record = {
+        "ts": int(time.time()),
+        "role": "Assistant_tool",
+        "tool_name": tool_name,
+        "tool_input": safe_tool_input,
+        "tool_output": _redact_string(output_text) if output_text else "",
+        "status": _derive_status(tool_response),
+    }
+    state.append(session_id, record)

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

@@ -0,0 +1,187 @@
+"""agent_end hook — finalize the assistant turn and publish to reflexio.
+
+This handler is the openClaw analogue of claude-smart's ``stop.py``, but
+substantially simpler. Per Phase 0 finding Q2, openClaw delivers the final
+messages inline as ``event.messages: unknown[]``, so we read assistant text
+directly from the payload instead of polling a transcript JSONL on disk.
+
+Pipeline:
+1. Extract final assistant text from ``payload.messages``.
+2. Parse ``[oc:…]`` citation markers from that text and resolve them
+   against the per-session injected registry.
+3. Append an ``Assistant`` record (always, even when the text is empty —
+   ``state.unpublished_slice`` folds any buffered ``Assistant_tool``
+   records into the next ``Assistant`` turn's ``tools_used``).
+4. Drain the buffer to reflexio via ``publish.publish_unpublished``.
+
+claude-smart's plan-mode decision scan and ``cs-cite`` Bash tool scan are
+intentionally NOT ported — both rely on Claude-Code-specific transcript
+shapes that openClaw does not emit.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from openclaw_smart import ids, oc_cite, publish, state
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _extract_assistant_text(messages: Any) -> str:
+    """Return the final assistant turn's text from a messages list.
+
+    Walks ``messages`` from the end, collecting every contiguous assistant
+    entry up to the most recent non-assistant boundary, then joins their
+    text content. Mirrors claude-smart's transcript walker but works on
+    inline message dicts.
+
+    Args:
+        messages (Any): openClaw's ``event.messages`` blob, expected to be
+            a list of dicts with ``role`` and ``content`` fields.
+
+    Returns:
+        str: Concatenated assistant text, or ``""`` when none is found.
+    """
+    if not isinstance(messages, list):
+        return ""
+    collected: list[str] = []
+    for entry in reversed(messages):
+        if not isinstance(entry, dict):
+            continue
+        role = _entry_role(entry)
+        if role != "assistant":
+            # Boundary — stop collecting; everything before this belongs to
+            # earlier turns and has already been (or will be) published.
+            break
+        content = _entry_content(entry)
+        text_parts = _extract_text_blocks(content)
+        if text_parts:
+            # Prepend because we walked in reverse order.
+            collected = text_parts + collected
+    return "\n\n".join(part for part in collected if part)
+
+
+def _entry_role(entry: dict[str, Any]) -> str:
+    """Read the role from an openClaw or Claude-Code-shaped message dict."""
+    role = entry.get("role")
+    if isinstance(role, str):
+        return role.lower()
+    message = entry.get("message")
+    if isinstance(message, dict):
+        nested = message.get("role")
+        if isinstance(nested, str):
+            return nested.lower()
+    return ""
+
+
+def _entry_content(entry: dict[str, Any]) -> Any:
+    """Return the content payload from a message entry, accepting both shapes."""
+    if "content" in entry:
+        return entry["content"]
+    message = entry.get("message")
+    if isinstance(message, dict):
+        return message.get("content")
+    return None
+
+
+def _extract_text_blocks(content: Any) -> list[str]:
+    """Return assistant-visible text from a message content payload.
+
+    Accepts:
+    - bare strings (``content: "hi"``)
+    - block lists (``content: [{type: "text", text: "hi"}, ...]``)
+    """
+    if isinstance(content, str):
+        return [content] if content else []
+    if not isinstance(content, list):
+        return []
+    out: list[str] = []
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        text = block.get("text")
+        if isinstance(text, str) and text:
+            out.append(text)
+            continue
+        inner = block.get("content")
+        if isinstance(inner, str) and inner:
+            out.append(inner)
+    return out
+
+
+def _resolve_cited_items(session_id: str, cited_ids: list[str]) -> list[dict[str, Any]]:
+    """Map citation ids to ``{id, kind, title}`` entries via the session registry.
+
+    Unknown ids (model hallucinations, or items injected in a newer session
+    than this hook can see) are dropped. Duplicate ids within one turn
+    collapse to a single entry — the user-facing badge row doesn't need
+    the multiplicity.
+    """
+    if not cited_ids:
+        return []
+    registry = state.read_injected(session_id)
+    seen: set[str] = set()
+    resolved: list[dict[str, Any]] = []
+    for cid in cited_ids:
+        if cid in seen:
+            continue
+        entry = registry.get(cid)
+        if not entry:
+            continue
+        seen.add(cid)
+        item: dict[str, Any] = {
+            "id": entry.get("id", cid),
+            "kind": entry.get("kind", ""),
+            "title": entry.get("title", ""),
+        }
+        real_id = entry.get("real_id")
+        if real_id:
+            item["real_id"] = real_id
+        source_kind = entry.get("source_kind")
+        if isinstance(source_kind, str) and source_kind:
+            item["source_kind"] = source_kind
+        resolved.append(item)
+    return resolved
+
+
+def handle(payload: dict[str, Any]) -> None:
+    """Finalize the current assistant turn and publish to reflexio.
+
+    Args:
+        payload (dict[str, Any]): openClaw event/ctx blob, expected to contain
+            ``sessionKey`` (or ``sessionId``), ``messages``, 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"),
+    )
+
+    assistant_text = _extract_assistant_text(payload.get("messages"))
+    cited_ids = oc_cite.parse_text_citations(assistant_text)
+    cited_items = _resolve_cited_items(session_id, cited_ids)
+
+    now = int(time.time())
+    record: dict[str, Any] = {
+        "ts": now,
+        "role": "Assistant",
+        "content": assistant_text,
+        "user_id": project_id,
+    }
+    if cited_items:
+        record["cited_items"] = cited_items
+    state.append(session_id, record)
+
+    publish.publish_unpublished(
+        session_id=session_id,
+        project_id=project_id,
+        force_extraction=False,
+        skip_aggregation=False,
+    )