codeframe-ai 0.9.0__py3-none-any.whl

codeframe/platform_store/repositories/base.py

@@ -0,0 +1,295 @@
+"""Base repository class for database operations."""
+
+import sqlite3
+import threading
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+import logging
+
+import aiosqlite
+
+logger = logging.getLogger(__name__)
+
+
+class BaseRepository:
+    """Base class for all repositories.
+
+    Provides common database utilities and connection management.
+    Each repository handles a specific domain (projects, issues, tasks, etc.).
+
+    Supports both synchronous (sqlite3) and asynchronous (aiosqlite) operations.
+    Thread-safe synchronous operations are provided via a shared lock.
+    """
+
+    def __init__(
+        self,
+        sync_conn: Optional[sqlite3.Connection] = None,
+        async_conn: Optional[aiosqlite.Connection] = None,
+        database: Optional[Any] = None,
+        sync_lock: Optional[threading.Lock] = None
+    ):
+        """Initialize repository with database connections.
+
+        Args:
+            sync_conn: Synchronous sqlite3.Connection
+            async_conn: Asynchronous aiosqlite.Connection
+            database: Reference to parent Database instance (for cross-repository operations)
+            sync_lock: Threading lock for thread-safe synchronous operations
+
+        Note:
+            At least one connection must be provided. Both can be provided
+            to support repositories with both sync and async methods.
+            If sync_conn is provided without sync_lock, operations will not be thread-safe.
+        """
+        if sync_conn is None and async_conn is None:
+            raise ValueError("At least one connection (sync or async) must be provided")
+
+        self.conn = sync_conn  # For backward compatibility
+        self._async_conn = async_conn
+        self._database = database  # Reference to parent Database instance
+        self._sync_lock = sync_lock  # Threading lock for thread-safe sync operations
+
+    def _execute(self, query: str, params: tuple = ()) -> sqlite3.Cursor:
+        """Execute a query synchronously with thread-safe locking.
+
+        Args:
+            query: SQL query string
+            params: Query parameters
+
+        Returns:
+            Cursor with query results
+
+        Raises:
+            RuntimeError: If sync connection is not available
+
+        Note:
+            Uses threading lock if available to ensure thread-safe access
+            to the shared connection object.
+        """
+        if self.conn is None:
+            raise RuntimeError("Sync connection not available, use async methods")
+
+        if self._sync_lock is not None:
+            with self._sync_lock:
+                return self.conn.execute(query, params)
+        else:
+            return self.conn.execute(query, params)
+
+    def _fetchone(self, query: str, params: tuple = ()) -> Optional[sqlite3.Row]:
+        """Fetch a single row synchronously.
+
+        Args:
+            query: SQL query string
+            params: Query parameters
+
+        Returns:
+            Row or None if no results
+        """
+        cursor = self._execute(query, params)
+        return cursor.fetchone()
+
+    def _fetchall(self, query: str, params: tuple = ()) -> List[sqlite3.Row]:
+        """Fetch all rows synchronously.
+
+        Args:
+            query: SQL query string
+            params: Query parameters
+
+        Returns:
+            List of rows
+        """
+        cursor = self._execute(query, params)
+        return cursor.fetchall()
+
+    def _commit(self) -> None:
+        """Commit the current transaction synchronously with thread-safe locking.
+
+        Raises:
+            RuntimeError: If sync connection is not available
+
+        Note:
+            Uses threading lock if available to ensure thread-safe access
+            to the shared connection object.
+        """
+        if self.conn is None:
+            raise RuntimeError("Sync connection not available, use async methods")
+
+        if self._sync_lock is not None:
+            with self._sync_lock:
+                self.conn.commit()
+        else:
+            self.conn.commit()
+
+    async def _execute_async(self, query: str, params: tuple = ()) -> aiosqlite.Cursor:
+        """Execute a query asynchronously.
+
+        Args:
+            query: SQL query string
+            params: Query parameters
+
+        Returns:
+            Cursor with query results
+
+        Raises:
+            RuntimeError: If async connection is not available
+        """
+        if self._async_conn is None:
+            raise RuntimeError("Async connection not available, use sync methods")
+        return await self._async_conn.execute(query, params)
+
+    async def _fetchone_async(self, query: str, params: tuple = ()) -> Optional[aiosqlite.Row]:
+        """Fetch a single row asynchronously.
+
+        Args:
+            query: SQL query string
+            params: Query parameters
+
+        Returns:
+            Row or None if no results
+        """
+        cursor = await self._execute_async(query, params)
+        return await cursor.fetchone()
+
+    async def _fetchall_async(self, query: str, params: tuple = ()) -> List[aiosqlite.Row]:
+        """Fetch all rows asynchronously.
+
+        Args:
+            query: SQL query string
+            params: Query parameters
+
+        Returns:
+            List of rows
+        """
+        cursor = await self._execute_async(query, params)
+        return await cursor.fetchall()
+
+    async def _commit_async(self) -> None:
+        """Commit the current transaction asynchronously.
+
+        Raises:
+            RuntimeError: If async connection is not available
+        """
+        if self._async_conn is None:
+            raise RuntimeError("Async connection not available, use sync methods")
+        await self._async_conn.commit()
+
+    def _row_to_dict(self, row: Union[sqlite3.Row, aiosqlite.Row]) -> Dict[str, Any]:
+        """Convert a database row to a dictionary.
+
+        Args:
+            row: SQLite Row object (sync or async)
+
+        Returns:
+            Dictionary with column names as keys
+
+        Note:
+            Both sqlite3.Row and aiosqlite.Row support dictionary-style access
+            and keys() method for column names.
+        """
+        if row is None:
+            return {}
+        return {key: row[key] for key in row.keys()}
+
+    def _parse_datetime(
+        self,
+        dt_str: Optional[str],
+        field_name: str = "",
+        row_id: Optional[int] = None
+    ) -> Optional[datetime]:
+        """Parse datetime string to datetime object.
+
+        Args:
+            dt_str: ISO format datetime string or None
+            field_name: Field name for logging (optional)
+            row_id: Row ID for logging (optional)
+
+        Returns:
+            datetime object or None if input is None
+
+        Raises:
+            ValueError: If datetime string is malformed
+        """
+        if dt_str is None:
+            return None
+
+        try:
+            # Parse ISO format: "2024-11-23T10:30:00" or "2024-11-23 10:30:00"
+            # Handle both 'T' and space separators
+            dt_str_normalized = dt_str.replace("T", " ")
+
+            # Try with microseconds first
+            try:
+                return datetime.fromisoformat(dt_str_normalized)
+            except ValueError:
+                # Try without microseconds
+                return datetime.strptime(dt_str_normalized, "%Y-%m-%d %H:%M:%S")
+        except (ValueError, AttributeError) as e:
+            context = f" for {field_name}" if field_name else ""
+            row_context = f" (row {row_id})" if row_id else ""
+            logger.warning(
+                f"Failed to parse datetime '{dt_str}'{context}{row_context}: {e}"
+            )
+            raise ValueError(f"Invalid datetime format: {dt_str}") from e
+
+    def _format_datetime(self, dt: Optional[datetime]) -> Optional[str]:
+        """Format datetime object to ISO string for database storage.
+
+        Args:
+            dt: datetime object or None
+
+        Returns:
+            ISO format datetime string or None
+        """
+        if dt is None:
+            return None
+        return dt.isoformat()
+
+    async def _get_async_conn(self) -> aiosqlite.Connection:
+        """Get async connection with health check and automatic reconnection.
+
+        This method delegates to the parent Database instance which:
+        1. Creates connection if none exists (lazy initialization)
+        2. Checks connection health via simple query
+        3. Reconnects automatically if connection is dead
+        4. Uses a lock to prevent race conditions
+
+        Returns:
+            Active aiosqlite connection
+
+        Raises:
+            RuntimeError: If database reference is not available
+            aiosqlite.Error: If connection cannot be established
+
+        Note:
+            Uses async connection with automatic health check and reconnection.
+            Call close_async() when done to release database resources.
+        """
+        if self._database is None:
+            raise RuntimeError("Database reference not available for async connection")
+        return await self._database._get_async_conn()
+
+    def _ensure_rfc3339(self, timestamp_str: Optional[str]) -> Optional[str]:
+        """Ensure timestamp is in RFC 3339 format with timezone.
+
+        Args:
+            timestamp_str: Timestamp string (may be SQLite format or RFC 3339)
+
+        Returns:
+            RFC 3339 formatted timestamp (with 'Z' suffix for UTC) or None
+
+        Note:
+            Converts SQLite timestamps like "2025-10-17 22:01:56" to "2025-10-17T22:01:56Z".
+            Timestamps already in RFC 3339 format are returned as-is.
+        """
+        if not timestamp_str:
+            return timestamp_str
+        # If already has 'Z' or timezone, return as-is
+        if "Z" in timestamp_str or "+" in timestamp_str:
+            return timestamp_str
+        # Parse and add Z suffix for UTC
+        try:
+            # SQLite format: "2025-10-17 22:01:56"
+            dt = datetime.fromisoformat(timestamp_str)
+            return dt.isoformat() + "Z"
+        except ValueError:
+            return timestamp_str

codeframe/platform_store/repositories/interactive_sessions.py

@@ -0,0 +1,165 @@
+"""Repository for interactive agent session operations."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, UTC
+from typing import Optional
+
+from codeframe.platform_store.repositories.base import BaseRepository
+
+
+class InteractiveSessionRepository(BaseRepository):
+    """Repository for interactive_sessions and session_messages tables."""
+
+    # -------------------------------------------------------------------------
+    # Sessions
+    # -------------------------------------------------------------------------
+
+    def create(
+        self,
+        workspace_path: str,
+        task_id: Optional[str] = None,
+        agent_type: str = "claude",
+        model: Optional[str] = None,
+    ) -> dict:
+        now = datetime.now(UTC).isoformat()
+        session_id = str(uuid.uuid4())
+        self._execute(
+            """
+            INSERT INTO interactive_sessions
+                (id, workspace_path, task_id, state, agent_type, model,
+                 cost_usd, input_tokens, output_tokens, created_at, updated_at, ended_at)
+            VALUES (?, ?, ?, 'active', ?, ?, 0.0, 0, 0, ?, ?, NULL)
+            """,
+            (session_id, workspace_path, task_id, agent_type, model, now, now),
+        )
+        self._commit()
+        return self.get(session_id)
+
+    def get(self, session_id: str) -> Optional[dict]:
+        row = self._fetchone(
+            "SELECT * FROM interactive_sessions WHERE id = ?", (session_id,)
+        )
+        return self._row_to_dict(row) if row else None
+
+    def list(
+        self,
+        workspace_path: Optional[str] = None,
+        state: Optional[str] = None,
+        limit: int = 50,
+    ) -> list[dict]:
+        query = "SELECT * FROM interactive_sessions WHERE 1=1"
+        params: list = []
+        if workspace_path is not None:
+            query += " AND workspace_path = ?"
+            params.append(workspace_path)
+        if state is not None:
+            query += " AND state = ?"
+            params.append(state)
+        query += " ORDER BY created_at DESC LIMIT ?"
+        params.append(limit)
+        rows = self._fetchall(query, tuple(params))
+        return [self._row_to_dict(r) for r in rows]
+
+    def update_state(self, session_id: str, state: str) -> None:
+        """Update session state. Called internally by the agent runtime, not via REST API.
+
+        Callers are responsible for validating state against VALID_STATES before calling.
+        """
+        now = datetime.now(UTC).isoformat()
+        self._execute(
+            "UPDATE interactive_sessions SET state = ?, updated_at = ? WHERE id = ?",
+            (state, now, session_id),
+        )
+        self._commit()
+
+    def update_cost(
+        self, session_id: str, cost_usd: float, input_tokens: int, output_tokens: int
+    ) -> None:
+        """Accumulate cost and token counts. Called internally by the agent runtime, not via REST API.
+
+        The increment is applied atomically at the DB level to prevent lost-update races.
+        """
+        now = datetime.now(UTC).isoformat()
+        self._execute(
+            """
+            UPDATE interactive_sessions
+            SET cost_usd = cost_usd + ?, input_tokens = input_tokens + ?,
+                output_tokens = output_tokens + ?, updated_at = ?
+            WHERE id = ?
+            """,
+            (cost_usd, input_tokens, output_tokens, now, session_id),
+        )
+        self._commit()
+
+    def end(self, session_id: str) -> Optional[dict]:
+        """End a session. Returns the updated row, or None if session_id not found."""
+        now = datetime.now(UTC).isoformat()
+        cursor = self._execute(
+            """
+            UPDATE interactive_sessions
+            SET state = 'ended', ended_at = ?, updated_at = ?
+            WHERE id = ?
+            """,
+            (now, now, session_id),
+        )
+        self._commit()
+        if cursor.rowcount == 0:
+            return None
+        return self.get(session_id)
+
+    # -------------------------------------------------------------------------
+    # Messages
+    # -------------------------------------------------------------------------
+
+    def add_message(
+        self,
+        session_id: str,
+        role: str,
+        content: str,
+        metadata: Optional[dict] = None,
+    ) -> dict:
+        now = datetime.now(UTC).isoformat()
+        message_id = str(uuid.uuid4())
+        metadata_json = json.dumps(metadata) if metadata is not None else None
+        self._execute(
+            """
+            INSERT INTO session_messages (id, session_id, role, content, metadata, created_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (message_id, session_id, role, content, metadata_json, now),
+        )
+        self._commit()
+        return {
+            "id": message_id,
+            "session_id": session_id,
+            "role": role,
+            "content": content,
+            "metadata": metadata,
+            "created_at": now,
+        }
+
+    def get_messages(
+        self, session_id: str, limit: int = 100, offset: int = 0
+    ) -> list[dict]:
+        rows = self._fetchall(
+            """
+            SELECT * FROM session_messages
+            WHERE session_id = ?
+            ORDER BY created_at
+            LIMIT ? OFFSET ?
+            """,
+            (session_id, limit, offset),
+        )
+        result = []
+        for row in rows:
+            d = self._row_to_dict(row)
+            if d.get("metadata"):
+                try:
+                    d["metadata"] = json.loads(d["metadata"])
+                except (json.JSONDecodeError, TypeError):
+                    d["metadata"] = None
+            result.append(d)
+        return result