claude-smart 0.2.49 → 0.2.50

package/plugin/src/claude_smart/publish.py

@@ -8,7 +8,8 @@ messaging without peeking at the adapter.
 
 from __future__ import annotations
 
-from typing import Literal
+import uuid
+from typing import Any, Literal
 
 from claude_smart import state
 from claude_smart.reflexio_adapter import Adapter
@@ -16,6 +17,50 @@ from claude_smart.reflexio_adapter import Adapter
 PublishStatus = Literal["nothing", "ok", "failed"]
 
 
+def _publish_request_id(session_id: str, start: int, end: int) -> str:
+    """Return a stable request ID for one buffered publish range."""
+
+    name = f"claude-smart:{session_id}:{start}:{end}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, name))
+
+
+def _prepare_publish_batch(
+    session_id: str,
+) -> tuple[int, int, list[dict[str, Any]]] | None:
+    """Freeze and return one canonical unpublished record range."""
+
+    while True:
+        records = state.read_all(session_id)
+        published, available = state.unpublished_slice(records)
+        if not available:
+            return None
+
+        publish_end = state.pending_publish_end(records, published)
+        if publish_end is None:
+            publish_end = state.safe_publish_end(records, published)
+            _, proposed = state.unpublished_slice(
+                records[:publish_end], published_override=published
+            )
+            if not proposed:
+                return None
+            state.append(
+                session_id,
+                {"publish_attempt": {"start": published, "end": publish_end}},
+            )
+
+        canonical = state.read_all(session_id)
+        if state.published_record_offset(canonical) != published:
+            continue
+        canonical_end = state.pending_publish_end(canonical, published)
+        if canonical_end is None:
+            continue
+        _, interactions = state.unpublished_slice(
+            canonical[:canonical_end], published_override=published
+        )
+        if interactions:
+            return published, canonical_end, interactions
+
+
 def publish_unpublished(
     *,
     session_id: str,
@@ -56,20 +101,27 @@ def publish_unpublished(
             was unreachable. On ``"failed"`` the watermark is not advanced,
             so the next hook retries the same batch.
     """
-    records = state.read_all(session_id)
-    _, interactions = state.unpublished_slice(records)
-    if not interactions:
+    batch = _prepare_publish_batch(session_id)
+    if batch is None:
         return ("nothing", 0)
+    published_record_offset, publish_end, interactions = batch
+
     client = adapter if adapter is not None else Adapter()
-    ok = client.publish(
+    request_id = _publish_request_id(session_id, published_record_offset, publish_end)
+    result = client.publish(
         session_id=session_id,
         project_id=project_id,
+        request_id=request_id,
         interactions=interactions,
         force_extraction=force_extraction,
         override_learning_stall=override_learning_stall,
         skip_aggregation=skip_aggregation,
     )
-    if ok:
-        state.append(session_id, {"published_up_to": len(records)})
+    if result:
+        marker: dict[str, Any] = {"published_up_to": publish_end}
+        confirmed_request_id = result.request_id
+        if isinstance(confirmed_request_id, str) and confirmed_request_id:
+            marker["request_id"] = confirmed_request_id
+        state.append(session_id, marker)
         return ("ok", len(interactions))
     return ("failed", len(interactions))

package/plugin/src/claude_smart/reflexio_adapter.py

@@ -20,7 +20,6 @@ _LOGGER = logging.getLogger(__name__)
 
 _ENV_URL = "REFLEXIO_URL"
 _ENV_API_KEY = "REFLEXIO_API_KEY"
-_DEFAULT_URL = "http://localhost:8071/"
 # Cap every HTTP round-trip from a hook so a hung backend can't stall the
 # Claude Code / Codex session. reflexio's client default is 300s, which is
 # fine for batch workloads but unacceptable on the hook path — a single
@@ -28,18 +27,48 @@ _DEFAULT_URL = "http://localhost:8071/"
 # in ``ids.py`` for short-lived hook HTTP calls.
 _HTTP_TIMEOUT_SECONDS = 5
 _SEARCH_MODE_HYBRID = "hybrid"  # reflexio.models.config_schema.SearchMode.HYBRID
+_SOURCE = "claude-smart"
 _UNIFIED_ENTITY_TYPES = ("profiles", "user_playbooks", "agent_playbooks")
 _AGENT_PLAYBOOK_APPROVAL_STATUSES = ("pending", "approved")
 _REJECTED_AGENT_PLAYBOOK_STATUS = "rejected"
+_LOCAL_8071_URLS = {
+    "http://localhost:8071",
+    "http://localhost:8071/",
+    "http://127.0.0.1:8071",
+    "http://127.0.0.1:8071/",
+}
+
+
+def _default_url() -> str:
+    return f"http://localhost:{os.environ.get('BACKEND_PORT', '8071')}/"
+
+
+def _configured_url() -> str:
+    url = os.environ.get(_ENV_URL, "")
+    backend_port = os.environ.get("BACKEND_PORT", "")
+    if url in _LOCAL_8071_URLS and backend_port not in {"", "8071"}:
+        return _default_url()
+    return url or _default_url()
+
+
+@dataclass(frozen=True)
+class PublishResult:
+    """Outcome and server-confirmed lineage for one publish call."""
+
+    ok: bool
+    request_id: str | None = None
+
+    def __bool__(self) -> bool:
+        return self.ok
 
 
 @dataclass
 class Adapter:
     """Wraps the reflexio client and absorbs connection errors.
 
-    All methods degrade to a neutral no-op return (empty list / False) on
-    connection failure so a missing or down reflexio server never crashes
-    a Claude Code hook.
+    All methods degrade to a neutral no-op result (an empty list or a falsey
+    result) on connection failure so a missing or down reflexio server never
+    crashes a host hook.
     """
 
     url: str = ""
@@ -48,7 +77,7 @@ class Adapter:
 
     def __post_init__(self) -> None:
         env_config.load_reflexio_env()
-        self.url = self.url or os.environ.get(_ENV_URL, _DEFAULT_URL)
+        self.url = self.url or _configured_url()
         self.api_key = self.api_key or os.environ.get(_ENV_API_KEY, "")
         self._client: Any | None = None
 
@@ -92,38 +121,96 @@ class Adapter:
         *,
         session_id: str,
         project_id: str,
+        request_id: str | None = None,
         interactions: Sequence[dict[str, Any]],
         force_extraction: bool = False,
         override_learning_stall: bool = False,
         skip_aggregation: bool = False,
-    ) -> bool:
-        """Publish buffered interactions to reflexio. Returns True on success."""
+    ) -> PublishResult:
+        """Publish interactions and return this call's confirmed request ID."""
         if not interactions:
-            return True
+            return PublishResult(True)
         client = self._get_client()
         if client is None:
-            return False
+            return PublishResult(False)
         try:
+            interaction_list = list(interactions)
+            raw_request = getattr(client, "_make_request", None)
+            supports_source = _supports_keyword(client.publish_interaction, "source")
+            if request_id is not None and callable(raw_request):
+                payload: dict[str, Any] = {
+                    "request_id": request_id,
+                    "user_id": project_id,
+                    "interaction_data_list": interaction_list,
+                    "agent_version": runtime.agent_version(),
+                    "session_id": session_id,
+                    "skip_aggregation": skip_aggregation,
+                    "force_extraction": force_extraction,
+                    "evaluation_only": False,
+                    "override_learning_stall": override_learning_stall,
+                }
+                if supports_source:
+                    payload["source"] = _SOURCE
+                try:
+                    raw_request(
+                        "POST",
+                        "/api/publish_interaction",
+                        json=payload,
+                        params=None,
+                    )
+                    return PublishResult(True, request_id)
+                except Exception as exc:  # noqa: BLE001
+                    if not _needs_raw_retrieved_learning_publish(interaction_list):
+                        raise
+                    _LOGGER.warning(
+                        "Could not confirm retrieved-learning links; retrying "
+                        "the base interaction with the same request ID: %s",
+                        exc,
+                    )
+                    fallback_payload = {
+                        **payload,
+                        "interaction_data_list": _without_retrieved_learnings(
+                            interaction_list
+                        ),
+                    }
+                    raw_request(
+                        "POST",
+                        "/api/publish_interaction",
+                        json=fallback_payload,
+                        params=None,
+                    )
+                    return PublishResult(True, request_id)
+            if _needs_raw_retrieved_learning_publish(interaction_list):
+                _LOGGER.warning(
+                    "Stable raw publishing is unavailable; publishing "
+                    "without optional retrieved-learning links"
+                )
+                interaction_list = _without_retrieved_learnings(interaction_list)
             kwargs = {
                 "user_id": project_id,
-                "interactions": list(interactions),
+                "interactions": interaction_list,
                 "agent_version": runtime.agent_version(),
                 "session_id": session_id,
                 "wait_for_response": False,
                 "force_extraction": force_extraction,
                 "skip_aggregation": skip_aggregation,
             }
+            if supports_source:
+                kwargs["source"] = _SOURCE
             if _supports_keyword(client.publish_interaction, "override_learning_stall"):
                 kwargs["override_learning_stall"] = override_learning_stall
             elif override_learning_stall:
                 _LOGGER.debug(
                     "publish_interaction client does not support override_learning_stall"
                 )
-            client.publish_interaction(**kwargs)
-            return True
+            response = client.publish_interaction(**kwargs)
+            response_request_id = getattr(response, "request_id", None)
+            if isinstance(response_request_id, str) and response_request_id:
+                return PublishResult(True, response_request_id)
+            return PublishResult(True)
         except Exception as exc:  # noqa: BLE001
             _LOGGER.warning("publish_interaction failed: %s", exc)
-            return False
+            return PublishResult(False)
 
     def apply_extraction_defaults(self, *, window_size: int, stride_size: int) -> bool:
         """Push claude-smart's preferred extraction defaults to the reflexio server.
@@ -340,7 +427,12 @@ class Adapter:
     # -----------------------------------------------------------------
 
     def search_all(
-        self, *, project_id: str, query: str, top_k: int = 5
+        self,
+        *,
+        project_id: str,
+        query: str,
+        top_k: int = 5,
+        session_id: str | None = None,
     ) -> tuple[list[Any], list[Any], list[Any]]:
         """Unified hybrid search → ``(user_playbooks, agent_playbooks, preferences)``.
 
@@ -354,6 +446,10 @@ class Adapter:
             project_id (str): reflexio ``user_id`` for this repo.
             query (str): Free-text query routed through BM25 + vector RRF.
             top_k (int): Cap on results per entity type.
+            session_id (str | None): Claude Code session id. When set, the
+                server skips results it already returned to this session
+                and backfills next-best matches, so repeated hook searches
+                within one session stop re-injecting the same rules.
 
         Returns:
             tuple[list[Any], list[Any], list[Any]]: ``(user_playbooks,
@@ -374,6 +470,7 @@ class Adapter:
                 enable_agent_answer=False,
                 top_k=top_k,
                 search_mode=_SEARCH_MODE_HYBRID,
+                session_id=session_id,
             )
         except Exception as exc:  # noqa: BLE001
             self._record_read_error("unified search", exc)
@@ -449,6 +546,32 @@ def _supports_keyword(callable_obj: Any, keyword: str) -> bool:
     return keyword in signature.parameters
 
 
+def _needs_raw_retrieved_learning_publish(
+    interactions: Sequence[dict[str, Any]],
+) -> bool:
+    """Return whether links require a caller-stable raw request.
+
+    The public client does not accept a caller-supplied request ID, and older
+    clients also strip this field. The authenticated helper preserves both.
+    """
+    return any(item.get("retrieved_learnings") for item in interactions)
+
+
+def _without_retrieved_learnings(
+    interactions: Sequence[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Copy interactions without the optional compatibility-only field."""
+
+    return [
+        {
+            key: value
+            for key, value in interaction.items()
+            if key != "retrieved_learnings"
+        }
+        for interaction in interactions
+    ]
+
+
 def _filter_rejected_agent_playbooks(items: list[Any]) -> list[Any]:
     """Drop rejected shared skills defensively, even if an older backend ignores filters."""
     return [

package/plugin/src/claude_smart/runtime.py

@@ -15,27 +15,36 @@ INTERNAL_ENV = "CLAUDE_SMART_INTERNAL"
 HOST_CLAUDE_CODE = "claude-code"
 HOST_CODEX = "codex"
 HOST_OPENCODE = "opencode"
+HOST_UNKNOWN = "unknown"
 VALID_HOSTS = frozenset({HOST_CLAUDE_CODE, HOST_CODEX, HOST_OPENCODE})
 
 _SHARED_AGENT_VERSION = "claude-code"
 _current_host: str | None = None
 
 
+def _resolve_host(value: str | None, fallback: str) -> str:
+    return value if value in VALID_HOSTS else fallback
+
+
 def set_host(value: str | None) -> str:
     """Set the current host, returning the normalized value."""
     global _current_host
-    host = value if value in VALID_HOSTS else HOST_CLAUDE_CODE
-    _current_host = host
+    _current_host = value if value is not None else HOST_UNKNOWN
+    host = _resolve_host(_current_host, HOST_CLAUDE_CODE)
     os.environ[HOST_ENV] = host
     return host
 
 
 def host() -> str:
     """Return the current host, defaulting to Claude Code for compatibility."""
-    if _current_host is not None:
-        return _current_host
-    value = os.environ.get(HOST_ENV)
-    return value if value in VALID_HOSTS else HOST_CLAUDE_CODE
+    value = _current_host if _current_host is not None else os.environ.get(HOST_ENV)
+    return _resolve_host(value, HOST_CLAUDE_CODE)
+
+
+def attribution_host() -> str:
+    """Return the explicitly selected record host, or unknown when unset."""
+    value = _current_host if _current_host is not None else os.environ.get(HOST_ENV)
+    return _resolve_host(value, HOST_UNKNOWN)
 
 
 def is_codex() -> bool: