claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_stall_state.py

@@ -0,0 +1,217 @@
+"""Singleton ``stall_state`` row — tracks whether reflexio's claude -p extractor
+is currently stalled by a billing or auth error.
+
+One row per database (``id`` is constrained to ``1``). The row always exists
+after schema init; ``stalled=0`` is the clean default. See the credit-stall
+notification spec for the state machine.
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from reflexio.models.api_schema.stall_state_schema import StallReason
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class StallState:
+    """Snapshot of the singleton stall row.
+
+    Attributes:
+        stalled (bool): True when learning is currently paused.
+        reason (StallReason | None): Why it's stalled. None when clean.
+        stalled_at (datetime | None): When the stall was first observed.
+        reset_estimate (datetime | None): Best-effort reset time parsed from
+            the error text. ``None`` for auth errors (no reset semantics).
+        notified_in_cc (bool): True once the SessionStart banner has fired
+            for this stall event.
+        error_message (str | None): Raw terminal-error text for debugging.
+    """
+
+    stalled: bool
+    reason: StallReason | None
+    stalled_at: datetime | None
+    reset_estimate: datetime | None
+    notified_in_cc: bool
+    error_message: str | None
+
+
+_CREATE_SQL = """
+CREATE TABLE IF NOT EXISTS stall_state (
+    id              INTEGER PRIMARY KEY CHECK (id = 1),
+    stalled         BOOLEAN NOT NULL DEFAULT 0,
+    reason          TEXT,
+    stalled_at      TIMESTAMP,
+    reset_estimate  TIMESTAMP,
+    notified_in_cc  BOOLEAN NOT NULL DEFAULT 0,
+    last_attempt_at TIMESTAMP,
+    error_message   TEXT
+);
+"""
+
+_SEED_SQL = "INSERT OR IGNORE INTO stall_state (id, stalled) VALUES (1, 0);"
+
+
+def init_stall_state_table(conn: sqlite3.Connection) -> None:
+    """Create the table and seed the singleton row. Idempotent.
+
+    Args:
+        conn (sqlite3.Connection): An open SQLite connection.
+    """
+    with conn:
+        conn.execute(_CREATE_SQL)
+        conn.execute(_SEED_SQL)
+
+
+def get_stall_state(conn: sqlite3.Connection) -> StallState:
+    """Return the current stall row.
+
+    Args:
+        conn (sqlite3.Connection): An open SQLite connection.
+
+    Returns:
+        StallState: Current snapshot of the singleton stall row.
+    """
+    row = conn.execute(
+        "SELECT stalled, reason, stalled_at, reset_estimate, "
+        "notified_in_cc, error_message FROM stall_state WHERE id = 1"
+    ).fetchone()
+    if row is None:
+        return StallState(False, None, None, None, False, None)
+    return StallState(
+        stalled=bool(row[0]),
+        reason=row[1],
+        stalled_at=_parse_ts(row[2]),
+        reset_estimate=_parse_ts(row[3]),
+        notified_in_cc=bool(row[4]),
+        error_message=row[5],
+    )
+
+
+def upsert_stall_state(
+    conn: sqlite3.Connection,
+    *,
+    reason: StallReason,
+    stalled_at: datetime,
+    reset_estimate: datetime | None,
+    error_message: str,
+) -> None:
+    """Mark the singleton as stalled with the given reason. Re-arms notified flag.
+
+    Args:
+        conn (sqlite3.Connection): An open SQLite connection.
+        reason (StallReason): The stall reason discriminator (``billing_error``
+            or ``auth_error``).
+        stalled_at (datetime): When the stall was first detected.
+        reset_estimate (datetime | None): Estimated reset time, if known.
+        error_message (str): Raw error text for debugging.
+    """
+    with conn:
+        conn.execute(
+            "UPDATE stall_state SET stalled=1, reason=?, stalled_at=?, "
+            "reset_estimate=?, notified_in_cc=0, last_attempt_at=?, "
+            "error_message=? WHERE id=1",
+            (
+                reason,
+                stalled_at.isoformat(),
+                reset_estimate.isoformat() if reset_estimate else None,
+                stalled_at.isoformat(),
+                error_message,
+            ),
+        )
+
+
+def mark_stall_notified(conn: sqlite3.Connection) -> None:
+    """Set ``notified_in_cc=1`` for the current stall. No-op when clean.
+
+    Args:
+        conn (sqlite3.Connection): An open SQLite connection.
+    """
+    with conn:
+        conn.execute("UPDATE stall_state SET notified_in_cc=1 WHERE id=1 AND stalled=1")
+
+
+def clear_stall_state(conn: sqlite3.Connection) -> None:
+    """Mark the singleton clean — clears all stall fields atomically.
+
+    Args:
+        conn (sqlite3.Connection): An open SQLite connection.
+    """
+    with conn:
+        conn.execute(
+            "UPDATE stall_state SET stalled=0, reason=NULL, stalled_at=NULL, "
+            "reset_estimate=NULL, notified_in_cc=0, error_message=NULL "
+            "WHERE id=1"
+        )
+
+
+def _parse_ts(raw: str | None) -> datetime | None:
+    """Parse ISO-format TIMESTAMP, tolerating None and naive strings.
+
+    Args:
+        raw (str | None): Raw ISO datetime string from SQLite, or None.
+
+    Returns:
+        datetime | None: Parsed datetime, or None if input is None or invalid.
+    """
+    if raw is None:
+        return None
+    try:
+        return datetime.fromisoformat(raw)
+    except ValueError:
+        _LOGGER.warning("Malformed timestamp in stall_state: %r", raw)
+        return None
+
+
+class SQLiteStallStateMixin:
+    """SQLite-backed stall_state operations exposed as storage methods."""
+
+    # Type hints for instance attributes provided by SQLiteStorageBase via MRO
+    conn: Any
+
+    def get_stall_state(self) -> StallState:
+        """Return the current stall row.
+
+        Returns:
+            StallState: Current snapshot of the singleton stall row.
+        """
+        return get_stall_state(self.conn)
+
+    def upsert_stall_state(
+        self,
+        *,
+        reason: StallReason,
+        stalled_at: datetime,
+        reset_estimate: datetime | None,
+        error_message: str,
+    ) -> None:
+        """Mark the singleton as stalled with the given reason. Re-arms notified flag.
+
+        Args:
+            reason (StallReason): The stall reason discriminator (``billing_error``
+                or ``auth_error``).
+            stalled_at (datetime): When the stall was first detected.
+            reset_estimate (datetime | None): Estimated reset time, if known.
+            error_message (str): Raw error text for debugging.
+        """
+        upsert_stall_state(
+            self.conn,
+            reason=reason,
+            stalled_at=stalled_at,
+            reset_estimate=reset_estimate,
+            error_message=error_message,
+        )
+
+    def mark_stall_notified(self) -> None:
+        """Set ``notified_in_cc=1`` for the current stall. No-op when clean."""
+        mark_stall_notified(self.conn)
+
+    def clear_stall_state(self) -> None:
+        """Mark the singleton clean — clears all stall fields atomically."""
+        clear_stall_state(self.conn)

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/__init__.py

@@ -0,0 +1,153 @@
+from reflexio.models.api_schema.domain.enums import Status
+
+from ._agent_run import (
+    NOT_APPLICABLE_ANSWER,
+    AgentBinding,
+    AgentRunMixin,
+    AgentRunRecord,
+    AgentRunStatus,
+    PendingToolCallRecord,
+    PendingToolCallStatus,
+    PendingToolCallUpsertResult,
+    PriorAnswerMatch,
+    RunToolDependencyKind,
+    RunToolDependencyRecord,
+    build_pending_tool_call_dedup_key,
+    build_scope_hash,
+    canonical_json,
+    embedding_similarity,
+    human_feedback_scope,
+    is_not_applicable_tool_result,
+    normalize_dedup_text,
+    not_applicable_tool_result,
+)
+from ._base import BaseStorageCore, matches_status_filter
+from ._extras import ExtrasMixin
+from ._operations import OperationMixin
+from ._playbook import PlaybookMixin
+from ._profiles import ProfileMixin
+from ._requests import RequestMixin
+from ._shadow_verdicts import ShadowVerdictsMixin
+from ._share_links import ShareLinkMixin
+from ._stall_state import StallStateMixin
+
+
+class BaseStorage(
+    AgentRunMixin,
+    ProfileMixin,
+    RequestMixin,
+    PlaybookMixin,
+    OperationMixin,
+    ExtrasMixin,
+    ShareLinkMixin,
+    StallStateMixin,
+    ShadowVerdictsMixin,
+    BaseStorageCore,
+):
+    """Base class for storage."""
+
+    def clear_user_data(self, user_id: str) -> dict[str, int]:
+        """Delete all rows scoped to a single ``user_id``.
+
+        Removes the user's interactions, user playbooks, profiles, and
+        requests. Intentionally does NOT touch ``agent_playbooks`` — those
+        are the cross-project rollup of skills and have no ``user_id``
+        column. This is the data-isolation primitive used by paired
+        protocols (e.g. SWE-bench) that share a single backend across
+        parallel tasks without one task's clear-all nuking another
+        in-flight task's rows.
+
+        The default implementation composes existing per-user / by-ids
+        primitives so any backend that implements those (sqlite, supabase,
+        postgres, ...) gets correct behaviour for free.
+        Subclasses MAY override for atomic / transactional efficiency.
+
+        Args:
+            user_id (str): The user id whose rows should be deleted.
+
+        Returns:
+            dict[str, int]: Per-entity deletion counts with keys
+                ``interactions``, ``user_playbooks``, ``profiles``, and
+                ``requests``. Counts reflect pre-deletion totals for the
+                user (i.e. how many rows existed for that user).
+        """
+        interaction_count = len(self.get_user_interaction(user_id))
+
+        # Snapshot user_playbook ids for the user so we can both count
+        # and delete via the existing bulk-by-ids primitive (no per-user
+        # playbook delete primitive exists at the mixin level).
+        user_playbook_ids = [
+            up.user_playbook_id
+            for up in self.get_user_playbooks(
+                user_id=user_id,
+                limit=1_000_000,
+                status_filter=[None, Status.ARCHIVED, Status.PENDING],
+            )
+            if up.user_playbook_id is not None
+        ]
+        profile_count = len(
+            self.get_user_profile(
+                user_id, status_filter=[None, Status.ARCHIVED, Status.PENDING]
+            )
+        )
+
+        # Snapshot request ids for the user so we can both count and
+        # delete via delete_requests_by_ids — there is no
+        # delete_all_requests_for_user primitive.
+        request_ids = [
+            session_item.request.request_id
+            for session_items in self.get_sessions(
+                user_id=user_id, top_k=1_000_000
+            ).values()
+            for session_item in session_items
+        ]
+
+        # Delete in dependency-safe order: interactions first (they
+        # reference requests), then user playbooks (also reference
+        # requests), then profiles, then the requests themselves.
+        self.delete_all_interactions_for_user(user_id)
+        deleted_user_playbooks = (
+            self.delete_user_playbooks_by_ids(user_playbook_ids)
+            if user_playbook_ids
+            else 0
+        )
+        self.delete_all_profiles_for_user(user_id)
+        deleted_requests = (
+            self.delete_requests_by_ids(request_ids) if request_ids else 0
+        )
+
+        return {
+            "interactions": interaction_count,
+            "user_playbooks": deleted_user_playbooks,
+            "profiles": profile_count,
+            "requests": deleted_requests,
+        }
+
+
+__all__ = [
+    "AgentBinding",
+    "AgentRunMixin",
+    "AgentRunRecord",
+    "AgentRunStatus",
+    "BaseStorage",
+    "NOT_APPLICABLE_ANSWER",
+    "PendingToolCallRecord",
+    "PendingToolCallStatus",
+    "PendingToolCallUpsertResult",
+    "PlaybookMixin",
+    "PriorAnswerMatch",
+    "RunToolDependencyKind",
+    "RunToolDependencyRecord",
+    "ShadowVerdictsMixin",
+    "ShareLinkMixin",
+    "StallStateMixin",
+    "build_pending_tool_call_dedup_key",
+    "build_scope_hash",
+    "canonical_json",
+    "embedding_similarity",
+    "human_feedback_scope",
+    "is_not_applicable_tool_result",
+    "matches_status_filter",
+    "not_applicable_tool_result",
+    "normalize_dedup_text",
+]