claude-smart 0.2.47 → 0.2.49

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/playbook/_user.py

@@ -71,6 +71,7 @@ class UserPlaybookStoreMixin:
     _delete_playbook_search_rows: Any
     _subject_ref_for_user_id: Any
     _assert_subject_writable_locked: Any
+    _own_transaction: Any
 
     def _subject_ref_from_user_playbook_row(self, row: sqlite3.Row) -> str:
         subject_ref = row["governance_subject_ref"]
@@ -119,8 +120,10 @@ class UserPlaybookStoreMixin:
 
             created_at_iso = _epoch_to_iso(up.created_at)
             with self._lock:
+                own_txn = self._own_transaction()
                 try:
-                    self.conn.execute("BEGIN IMMEDIATE")
+                    if own_txn:
+                        self.conn.execute("BEGIN IMMEDIATE")
                     self._assert_subject_writable_locked(subject_ref)
                     cur = self.conn.execute(
                         """INSERT INTO user_playbooks
@@ -159,9 +162,11 @@ class UserPlaybookStoreMixin:
                     )
                     upid = cur.lastrowid or 0
                     up.user_playbook_id = upid
-                    self.conn.commit()
+                    if own_txn:
+                        self.conn.commit()
                 except Exception:
-                    self.conn.rollback()
+                    if own_txn:
+                        self.conn.rollback()
                     raise
 
             fts_parts = [up.trigger or "", up.content or ""]
@@ -230,7 +235,8 @@ class UserPlaybookStoreMixin:
             params.extend(sparams)
         else:
             # Default: exclude tombstone statuses (MERGED/SUPERSEDED)
-            sql += " AND (status IS NULL OR status NOT IN (?, ?))"
+            _ph = ",".join("?" * len(_TOMBSTONE_STATUS_VALUES))
+            sql += f" AND (status IS NULL OR status NOT IN ({_ph}))"
             params.extend(_TOMBSTONE_STATUS_VALUES)
         tag_frag, tag_params = _build_tags_sql("user_playbooks", tags)
         if tag_frag:
@@ -274,7 +280,8 @@ class UserPlaybookStoreMixin:
             params.extend(sparams)
         else:
             # Default: exclude tombstone statuses (MERGED/SUPERSEDED)
-            sql += " AND (status IS NULL OR status NOT IN (?, ?))"
+            _ph = ",".join("?" * len(_TOMBSTONE_STATUS_VALUES))
+            sql += f" AND (status IS NULL OR status NOT IN ({_ph}))"
             params.extend(_TOMBSTONE_STATUS_VALUES)
 
         row = self._fetchone(sql, params)
@@ -282,11 +289,12 @@ class UserPlaybookStoreMixin:
 
     @SQLiteStorageBase.handle_exceptions
     def count_user_playbooks_by_session(self, session_id: str) -> int:
+        _ph = ",".join("?" * len(_TOMBSTONE_STATUS_VALUES))
         row = self._fetchone(
-            """SELECT COUNT(*) as cnt FROM user_playbooks up
+            f"""SELECT COUNT(*) as cnt FROM user_playbooks up
                JOIN requests r ON up.request_id = r.request_id
                WHERE r.session_id = ?
-                 AND (up.status IS NULL OR up.status NOT IN (?, ?))""",
+                 AND (up.status IS NULL OR up.status NOT IN ({_ph}))""",  # noqa: S608
             (session_id, *_TOMBSTONE_STATUS_VALUES),
         )
         return row["cnt"] if row else 0
@@ -620,7 +628,8 @@ class UserPlaybookStoreMixin:
             params.extend(sparams)
         else:
             # Default: exclude tombstone statuses (MERGED/SUPERSEDED)
-            conditions.append("(up.status IS NULL OR up.status NOT IN (?, ?))")
+            _ph = ",".join("?" * len(_TOMBSTONE_STATUS_VALUES))
+            conditions.append(f"(up.status IS NULL OR up.status NOT IN ({_ph}))")
             params.extend(_TOMBSTONE_STATUS_VALUES)
         tag_frag, tag_params = _build_tags_sql("up", request.tags)
         if tag_frag:
@@ -695,7 +704,8 @@ class UserPlaybookStoreMixin:
     ) -> UserPlaybook | None:
         sql = "SELECT * FROM user_playbooks WHERE user_playbook_id = ?"
         if not include_tombstones:
-            sql += " AND (status IS NULL OR status NOT IN (?, ?))"
+            _ph = ",".join("?" * len(_TOMBSTONE_STATUS_VALUES))
+            sql += f" AND (status IS NULL OR status NOT IN ({_ph}))"
             row = self._fetchone(sql, (user_playbook_id, *_TOMBSTONE_STATUS_VALUES))
         else:
             row = self._fetchone(sql, (user_playbook_id,))
@@ -784,7 +794,8 @@ class UserPlaybookStoreMixin:
                         to_status=None,
                         status_namespace=None,
                     )
-                self.conn.commit()
+                if self._own_transaction():
+                    self.conn.commit()
 
     @SQLiteStorageBase.handle_exceptions
     def supersede_user_playbooks_by_ids(
@@ -814,10 +825,11 @@ class UserPlaybookStoreMixin:
                     self._subject_ref_from_user_playbook_row(row)
                 )
                 old_status = row["status"]
+                _ph = ",".join("?" * len(_TOMBSTONE_STATUS_VALUES))
                 cur = self.conn.execute(
                     "UPDATE user_playbooks SET status = ?, retired_at = ?"
                     " WHERE user_playbook_id = ?"
-                    " AND (status IS NULL OR status NOT IN (?, ?))",
+                    f" AND (status IS NULL OR status NOT IN ({_ph}))",
                     (
                         Status.SUPERSEDED.value,
                         now_ts,
@@ -834,5 +846,6 @@ class UserPlaybookStoreMixin:
                         request_id=request_id,
                     )
                     updated += 1
-            self.conn.commit()
+            if self._own_transaction():
+                self.conn.commit()
         return updated

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/profiles/__init__.py

@@ -0,0 +1,9 @@
+from ._interaction_store import InteractionStoreMixin
+from ._profile_store import ProfileStoreMixin
+from ._search import ProfileSearchMixin
+
+__all__ = [
+    "InteractionStoreMixin",
+    "ProfileSearchMixin",
+    "ProfileStoreMixin",
+]

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/profiles/_interaction_store.py

@@ -0,0 +1,308 @@
+"""Interaction store CRUD methods for SQLite storage.
+
+Extracted verbatim from ``_profiles.py`` (the InteractionStore bucket). Profile
+CRUD lives in ``profiles._profile_store`` (``ProfileStoreMixin``); search methods
+live in ``profiles._search`` (``ProfileSearchMixin``).
+"""
+
+import logging
+import sqlite3
+from typing import Any
+
+from reflexio.models.api_schema.service_schemas import (
+    DeleteUserInteractionRequest,
+    Interaction,
+)
+from reflexio.server.llm.providers.embedding_service_provider import (
+    EmbeddingUnavailableError,
+)
+
+from .._base import (
+    SQLiteStorageBase,
+    _epoch_to_iso,
+    _json_dumps,
+    _row_to_interaction,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class InteractionStoreMixin:
+    """Mixin providing interaction-store CRUD for SQLite storage."""
+
+    # Type hints for instance attributes/methods provided by SQLiteStorageBase via MRO
+    _lock: Any
+    conn: sqlite3.Connection
+    _fetchone: Any
+    _fetchall: Any
+    _get_embedding: Any
+    _fts_upsert: Any
+    _vec_upsert: Any
+    _delete_in_chunks: Any
+    _has_sqlite_vec: bool
+    llm_client: Any
+    embedding_model_name: str
+    embedding_dimensions: int
+    _subject_ref_for_user_id: Any
+    _assert_subject_writable_locked: Any
+    _own_transaction: Any
+
+    # ------------------------------------------------------------------
+    # CRUD — Interactions
+    # ------------------------------------------------------------------
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_all_interactions(self, limit: int = 100) -> list[Interaction]:
+        rows = self._fetchall(
+            "SELECT * FROM interactions ORDER BY created_at DESC LIMIT ?", (limit,)
+        )
+        return [_row_to_interaction(r) for r in rows]
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_user_interaction(self, user_id: str) -> list[Interaction]:
+        rows = self._fetchall(
+            "SELECT * FROM interactions WHERE user_id = ?", (user_id,)
+        )
+        return [_row_to_interaction(r) for r in rows]
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_all_user_ids(self) -> list[str]:
+        rows = self._fetchall("SELECT DISTINCT user_id FROM interactions")
+        return sorted(r["user_id"] for r in rows)
+
+    @SQLiteStorageBase.handle_exceptions
+    def add_user_interaction(self, user_id: str, interaction: Interaction) -> None:  # noqa: ARG002
+        embedding = self._get_embedding(
+            f"{interaction.content}\n{interaction.user_action_description}"
+        )
+        interaction.embedding = embedding
+        self._insert_interaction(interaction)
+
+    def _insert_interaction(self, interaction: Interaction) -> int:
+        created_at_iso = _epoch_to_iso(interaction.created_at)
+        subject_ref = self._subject_ref_for_user_id(interaction.user_id)
+        with self._lock:
+            own_txn = self._own_transaction()
+            try:
+                if own_txn:
+                    self.conn.execute("BEGIN IMMEDIATE")
+                self._assert_subject_writable_locked(subject_ref)
+                if interaction.interaction_id:
+                    self.conn.execute(
+                        """INSERT OR REPLACE INTO interactions
+                           (interaction_id, user_id, content, request_id, created_at,
+                            role, user_action, user_action_description,
+                            interacted_image_url, image_encoding, shadow_content,
+                            expert_content, tools_used, citations, embedding, governance_subject_ref)
+                           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                        (
+                            interaction.interaction_id,
+                            interaction.user_id,
+                            interaction.content,
+                            interaction.request_id,
+                            created_at_iso,
+                            interaction.role,
+                            interaction.user_action.value,
+                            interaction.user_action_description,
+                            interaction.interacted_image_url,
+                            interaction.image_encoding,
+                            interaction.shadow_content,
+                            interaction.expert_content,
+                            _json_dumps(
+                                [t.model_dump() for t in interaction.tools_used]
+                            ),
+                            _json_dumps(
+                                [c.model_dump() for c in interaction.citations]
+                            ),
+                            _json_dumps(interaction.embedding),
+                            subject_ref,
+                        ),
+                    )
+                    iid = interaction.interaction_id
+                else:
+                    cur = self.conn.execute(
+                        """INSERT INTO interactions
+                           (user_id, content, request_id, created_at,
+                            role, user_action, user_action_description,
+                            interacted_image_url, image_encoding, shadow_content,
+                            expert_content, tools_used, citations, embedding, governance_subject_ref)
+                           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                        (
+                            interaction.user_id,
+                            interaction.content,
+                            interaction.request_id,
+                            created_at_iso,
+                            interaction.role,
+                            interaction.user_action.value,
+                            interaction.user_action_description,
+                            interaction.interacted_image_url,
+                            interaction.image_encoding,
+                            interaction.shadow_content,
+                            interaction.expert_content,
+                            _json_dumps(
+                                [t.model_dump() for t in interaction.tools_used]
+                            ),
+                            _json_dumps(
+                                [c.model_dump() for c in interaction.citations]
+                            ),
+                            _json_dumps(interaction.embedding),
+                            subject_ref,
+                        ),
+                    )
+                    iid = cur.lastrowid or 0
+                    interaction.interaction_id = iid
+                if own_txn:
+                    self.conn.commit()
+            except Exception:
+                if own_txn:
+                    self.conn.rollback()
+                raise
+        # Update FTS and vec
+        self._fts_upsert(
+            "interactions_fts",
+            iid,
+            content=interaction.content,
+            user_action_description=interaction.user_action_description,
+        )
+        if interaction.embedding:
+            self._vec_upsert("interactions_vec", iid, interaction.embedding)
+        return iid
+
+    @SQLiteStorageBase.handle_exceptions
+    def add_user_interactions_bulk(
+        self,
+        user_id: str,  # noqa: ARG002
+        interactions: list[Interaction],
+        *,
+        embeddings_prepared: bool = False,
+    ) -> None:
+        if not interactions:
+            return
+        if not embeddings_prepared:
+            # Only generate embeddings for interactions that do not already have them.
+            # This allows callers to pre-populate embeddings (e.g. via
+            # prepare_interaction_embeddings) before opening a commit_scope so that no
+            # network I/O occurs inside the transaction.
+            to_embed = [i for i in interactions if not i.embedding]
+            if to_embed:
+                texts = [
+                    "\n".join([i.content or "", i.user_action_description or ""])
+                    for i in to_embed
+                ]
+                try:
+                    embeddings = self.llm_client.get_embeddings(
+                        texts, self.embedding_model_name, self.embedding_dimensions
+                    )
+                except EmbeddingUnavailableError as exc:
+                    logger.warning(
+                        "Embedding unavailable for interaction bulk insert; "
+                        "continuing without vectors: %s",
+                        exc,
+                    )
+                    embeddings = [[] for _ in texts]
+                for interaction, embedding in zip(to_embed, embeddings, strict=False):
+                    interaction.embedding = embedding
+        for interaction in interactions:
+            self._insert_interaction(interaction)
+
+    @SQLiteStorageBase.handle_exceptions
+    def prepare_interaction_embeddings(self, interactions: list[Interaction]) -> None:
+        """Pre-populate interaction.embedding for each interaction (no DB write).
+
+        Generates embeddings in one batch call so the write path inside a
+        commit_scope can skip the network round-trip.
+        """
+        if not interactions:
+            return
+        to_embed = [i for i in interactions if not i.embedding]
+        if not to_embed:
+            return
+        texts = [
+            "\n".join([i.content or "", i.user_action_description or ""])
+            for i in to_embed
+        ]
+        try:
+            embeddings = self.llm_client.get_embeddings(
+                texts, self.embedding_model_name, self.embedding_dimensions
+            )
+        except EmbeddingUnavailableError as exc:
+            logger.warning(
+                "Embedding unavailable during prepare_interaction_embeddings; "
+                "continuing without vectors: %s",
+                exc,
+            )
+            embeddings = [[] for _ in texts]
+        for interaction, embedding in zip(to_embed, embeddings, strict=False):
+            interaction.embedding = embedding
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_user_interaction(self, request: DeleteUserInteractionRequest) -> None:
+        with self._lock:
+            row = self.conn.execute(
+                "SELECT interaction_id FROM interactions WHERE user_id = ? AND interaction_id = ?",
+                (request.user_id, request.interaction_id),
+            ).fetchone()
+            if row is None:
+                return
+            self.conn.execute(
+                "DELETE FROM interactions_fts WHERE rowid = ?",
+                (request.interaction_id,),
+            )
+            if self._has_sqlite_vec:
+                self.conn.execute(
+                    "DELETE FROM interactions_vec WHERE rowid = ?",
+                    (request.interaction_id,),
+                )
+            self.conn.execute(
+                "DELETE FROM interactions WHERE user_id = ? AND interaction_id = ?",
+                (request.user_id, request.interaction_id),
+            )
+            self.conn.commit()
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_all_interactions_for_user(self, user_id: str) -> None:
+        with self._lock:
+            rows = self.conn.execute(
+                "SELECT interaction_id FROM interactions WHERE user_id = ?", (user_id,)
+            ).fetchall()
+            if not rows:
+                return
+            ids = [r["interaction_id"] for r in rows]
+            self._delete_in_chunks("interactions_fts", "rowid", ids)
+            if self._has_sqlite_vec:
+                self._delete_in_chunks("interactions_vec", "rowid", ids)
+            self.conn.execute("DELETE FROM interactions WHERE user_id = ?", (user_id,))
+            self.conn.commit()
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_all_interactions(self) -> None:
+        with self._lock:
+            self.conn.execute("DELETE FROM interactions_fts")
+            if self._has_sqlite_vec:
+                self.conn.execute("DELETE FROM interactions_vec")
+            self.conn.execute("DELETE FROM interactions")
+            self.conn.commit()
+
+    @SQLiteStorageBase.handle_exceptions
+    def count_all_interactions(self) -> int:
+        row = self._fetchone("SELECT COUNT(*) as cnt FROM interactions")
+        return row["cnt"] if row else 0
+
+    @SQLiteStorageBase.handle_exceptions
+    def delete_oldest_interactions(self, count: int) -> int:
+        if count <= 0:
+            return 0
+        with self._lock:
+            rows = self.conn.execute(
+                "SELECT interaction_id FROM interactions ORDER BY created_at ASC LIMIT ?",
+                (count,),
+            ).fetchall()
+            if not rows:
+                return 0
+            ids = [r["interaction_id"] for r in rows]
+            self._delete_in_chunks("interactions_fts", "rowid", ids)
+            if self._has_sqlite_vec:
+                self._delete_in_chunks("interactions_vec", "rowid", ids)
+            self._delete_in_chunks("interactions", "interaction_id", ids)
+            self.conn.commit()
+        return len(ids)