appkit-assistant 0.13.0__tar.gz → 0.14.0__tar.gz

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appkit-assistant
-Version: 0.13.0
+Version: 0.14.0
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/jenreh/appkit
 Project-URL: Documentation, https://github.com/jenreh/appkit/tree/main/docs
@@ -40,6 +40,7 @@ appkit-assistant provides a complete conversational AI interface built on Reflex
 
 - **Multi-Model Support** - OpenAI Chat Completions, OpenAI Responses API, Perplexity, and fallback Lorem Ipsum processor
 - **MCP Server Integration** - Manage and connect to Model Context Protocol servers as tools
+- **System Prompt Management** - Versioned system prompts with admin editor interface
 - **Secure Credential Management** - Encrypted storage and handling of API keys and server credentials
 - **Reflex UI Components** - Pre-built assistant interface with composer, thread management, and message display
 - **Streaming Responses** - Real-time streaming of AI responses with chunked content
@@ -114,11 +115,11 @@ manager.register_processor("perplexity", PerplexityProcessor(assistant_config))
 
 ```python
 import reflex as rx
-import appkit_assistant as assistant
+from appkit_assistant.components import Assistant
 
 def assistant_page():
     return rx.container(
-        assistant.Assistant(),
+        Assistant(),
         height="100vh"
     )
 ```
@@ -188,10 +189,10 @@ async for chunk in processor.process(messages, "gpt-4", mcp_servers=[mcp_server]
 The main `Assistant` component provides a complete chat interface:
 
 ```python
-import appkit_assistant as assistant
+from appkit_assistant.components import Assistant
 
 def chat_page():
-    return assistant.Assistant()
+    return Assistant()
 ```
 
 #### Individual Components
@@ -199,12 +200,13 @@ def chat_page():
 Use individual components for custom layouts:
 
 ```python
-import appkit_assistant as assistant
+import reflex as rx
+from appkit_assistant.components import ThreadList, composer
 
 def custom_assistant():
     return rx.vstack(
-        assistant.ThreadList(),
-        assistant.composer(),
+        ThreadList(),
+        composer(),
         spacing="4"
     )
 ```
@@ -214,8 +216,21 @@ def custom_assistant():
 Display and manage MCP servers:
 
 ```python
+from appkit_assistant.components import mcp_servers_table
+
 def servers_page():
-    return assistant.mcp_servers_table()
+    return mcp_servers_table()
+```
+
+#### System Prompt Editor
+
+Admin interface for managing versioned system prompts:
+
+```python
+from appkit_assistant.components.system_prompt_editor import system_prompt_editor
+
+def prompt_editor_page():
+    return system_prompt_editor()
 ```
 
 ---
@@ -279,6 +294,8 @@ manager.register_processor("lorem", LoremIpsumProcessor())
 - `ThreadList` - Conversation thread list
 - `MessageComponent` - Individual message display
 - `mcp_servers_table` - MCP server management table
+- `system_prompt_editor` - Admin interface for system prompts
+
 
 ### State Management
 

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/README.md

@@ -15,6 +15,7 @@ appkit-assistant provides a complete conversational AI interface built on Reflex
 
 - **Multi-Model Support** - OpenAI Chat Completions, OpenAI Responses API, Perplexity, and fallback Lorem Ipsum processor
 - **MCP Server Integration** - Manage and connect to Model Context Protocol servers as tools
+- **System Prompt Management** - Versioned system prompts with admin editor interface
 - **Secure Credential Management** - Encrypted storage and handling of API keys and server credentials
 - **Reflex UI Components** - Pre-built assistant interface with composer, thread management, and message display
 - **Streaming Responses** - Real-time streaming of AI responses with chunked content
@@ -89,11 +90,11 @@ manager.register_processor("perplexity", PerplexityProcessor(assistant_config))
 
 ```python
 import reflex as rx
-import appkit_assistant as assistant
+from appkit_assistant.components import Assistant
 
 def assistant_page():
     return rx.container(
-        assistant.Assistant(),
+        Assistant(),
         height="100vh"
     )
 ```
@@ -163,10 +164,10 @@ async for chunk in processor.process(messages, "gpt-4", mcp_servers=[mcp_server]
 The main `Assistant` component provides a complete chat interface:
 
 ```python
-import appkit_assistant as assistant
+from appkit_assistant.components import Assistant
 
 def chat_page():
-    return assistant.Assistant()
+    return Assistant()
 ```
 
 #### Individual Components
@@ -174,12 +175,13 @@ def chat_page():
 Use individual components for custom layouts:
 
 ```python
-import appkit_assistant as assistant
+import reflex as rx
+from appkit_assistant.components import ThreadList, composer
 
 def custom_assistant():
     return rx.vstack(
-        assistant.ThreadList(),
-        assistant.composer(),
+        ThreadList(),
+        composer(),
         spacing="4"
     )
 ```
@@ -189,8 +191,21 @@ def custom_assistant():
 Display and manage MCP servers:
 
 ```python
+from appkit_assistant.components import mcp_servers_table
+
 def servers_page():
-    return assistant.mcp_servers_table()
+    return mcp_servers_table()
+```
+
+#### System Prompt Editor
+
+Admin interface for managing versioned system prompts:
+
+```python
+from appkit_assistant.components.system_prompt_editor import system_prompt_editor
+
+def prompt_editor_page():
+    return system_prompt_editor()
 ```
 
 ---
@@ -254,6 +269,8 @@ manager.register_processor("lorem", LoremIpsumProcessor())
 - `ThreadList` - Conversation thread list
 - `MessageComponent` - Individual message display
 - `mcp_servers_table` - MCP server management table
+- `system_prompt_editor` - Admin interface for system prompts
+
 
 ### State Management
 

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/pyproject.toml

@@ -7,7 +7,7 @@ dependencies = [
     "reflex>=0.8.22",
 ]
 name = "appkit-assistant"
-version = "0.13.0"
+version = "0.14.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [{ name = "Jens Rehpöhler" }]

appkit_assistant-0.14.0/src/appkit_assistant/backend/repositories.py

@@ -0,0 +1,162 @@
+"""Repository for MCP server data access operations."""
+
+import logging
+from datetime import UTC, datetime
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import defer
+
+from appkit_assistant.backend.models import (
+    AssistantThread,
+    MCPServer,
+    SystemPrompt,
+)
+from appkit_commons.database.base_repository import BaseRepository
+
+logger = logging.getLogger(__name__)
+
+
+class MCPServerRepository(BaseRepository[MCPServer, AsyncSession]):
+    """Repository class for MCP server database operations."""
+
+    @property
+    def model_class(self) -> type[MCPServer]:
+        return MCPServer
+
+    async def find_all_ordered_by_name(self, session: AsyncSession) -> list[MCPServer]:
+        """Retrieve all MCP servers ordered by name."""
+        stmt = select(MCPServer).order_by(MCPServer.name)
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
+
+
+class SystemPromptRepository(BaseRepository[SystemPrompt, AsyncSession]):
+    """Repository class for system prompt database operations.
+
+    Implements append-only versioning with full CRUD capabilities.
+    """
+
+    @property
+    def model_class(self) -> type[SystemPrompt]:
+        return SystemPrompt
+
+    async def find_all_ordered_by_version_desc(
+        self, session: AsyncSession
+    ) -> list[SystemPrompt]:
+        """Retrieve all system prompt versions ordered by version descending."""
+        stmt = select(SystemPrompt).order_by(SystemPrompt.version.desc())
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def find_latest(self, session: AsyncSession) -> SystemPrompt | None:
+        """Retrieve the latest system prompt version."""
+        stmt = select(SystemPrompt).order_by(SystemPrompt.version.desc()).limit(1)
+        result = await session.execute(stmt)
+        return result.scalars().first()
+
+    async def create_next_version(
+        self, session: AsyncSession, prompt: str, user_id: int
+    ) -> SystemPrompt:
+        """Neue System Prompt Version anlegen.
+
+        Version ist fortlaufende Ganzzahl, beginnend bei 1.
+        """
+        stmt = select(SystemPrompt).order_by(SystemPrompt.version.desc()).limit(1)
+        result = await session.execute(stmt)
+        latest = result.scalars().first()
+        next_version = (latest.version + 1) if latest else 1
+
+        name = f"Version {next_version}"
+
+        system_prompt = SystemPrompt(
+            name=name,
+            prompt=prompt,
+            version=next_version,
+            user_id=user_id,
+            created_at=datetime.now(UTC),
+        )
+        session.add(system_prompt)
+        await session.flush()
+        await session.refresh(system_prompt)
+
+        logger.info(
+            "Created system prompt version %s for user %s",
+            next_version,
+            user_id,
+        )
+        return system_prompt
+
+
+class ThreadRepository(BaseRepository[AssistantThread, AsyncSession]):
+    """Repository class for Thread database operations."""
+
+    @property
+    def model_class(self) -> type[AssistantThread]:
+        return AssistantThread
+
+    async def find_by_user(
+        self, session: AsyncSession, user_id: int
+    ) -> list[AssistantThread]:
+        """Retrieve all threads for a user."""
+        stmt = (
+            select(AssistantThread)
+            .where(AssistantThread.user_id == user_id)
+            .order_by(AssistantThread.updated_at.desc())
+        )
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
+
+    async def find_by_thread_id(
+        self, session: AsyncSession, thread_id: str
+    ) -> AssistantThread | None:
+        """Retrieve a thread by its thread_id."""
+        stmt = select(AssistantThread).where(AssistantThread.thread_id == thread_id)
+        result = await session.execute(stmt)
+        return result.scalars().first()
+
+    async def find_by_thread_id_and_user(
+        self, session: AsyncSession, thread_id: str, user_id: int
+    ) -> AssistantThread | None:
+        """Retrieve a thread by thread_id and user_id."""
+        stmt = select(AssistantThread).where(
+            AssistantThread.thread_id == thread_id,
+            AssistantThread.user_id == user_id,
+        )
+        result = await session.execute(stmt)
+        return result.scalars().first()
+
+    async def delete_by_thread_id_and_user(
+        self, session: AsyncSession, thread_id: str, user_id: int
+    ) -> bool:
+        """Delete a thread by thread_id and user_id."""
+        stmt = select(AssistantThread).where(
+            AssistantThread.thread_id == thread_id,
+            AssistantThread.user_id == user_id,
+        )
+        result = await session.execute(stmt)
+        thread = result.scalars().first()
+        if thread:
+            await session.delete(thread)
+            await session.flush()
+            return True
+        return False
+
+    async def find_summaries_by_user(
+        self, session: AsyncSession, user_id: int
+    ) -> list[AssistantThread]:
+        """Retrieve thread summaries (no messages) for a user."""
+        stmt = (
+            select(AssistantThread)
+            .where(AssistantThread.user_id == user_id)
+            .options(defer(AssistantThread.messages))
+            .order_by(AssistantThread.updated_at.desc())
+        )
+        result = await session.execute(stmt)
+        return list(result.scalars().all())
+
+
+# Export instances
+mcp_server_repo = MCPServerRepository()
+system_prompt_repo = SystemPromptRepository()
+thread_repo = ThreadRepository()

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/src/appkit_assistant/backend/system_prompt_cache.py

@@ -3,7 +3,8 @@ import logging
 from datetime import UTC, datetime, timedelta
 from typing import Final
 
-from appkit_assistant.backend.repositories import SystemPromptRepository
+from appkit_assistant.backend.repositories import system_prompt_repo
+from appkit_commons.database.session import get_asyncdb_session
 
 logger = logging.getLogger(__name__)
 
@@ -81,15 +82,24 @@ class SystemPromptCache:
             # Cache miss or expired - fetch from database
             logger.info("Cache miss - fetching latest prompt from database")
 
-            latest_prompt = await SystemPromptRepository.get_latest()
+            async with get_asyncdb_session() as session:
+                latest_prompt = await system_prompt_repo.find_latest(session)
+
+                if latest_prompt is None:
+                    # Raise inside to exit or handle outside
+                    pass
+                else:
+                    # Capture values while attached
+                    prompt_text = latest_prompt.prompt
+                    prompt_version = latest_prompt.version
 
             if latest_prompt is None:
                 msg = "No system prompt found in database"
                 logger.error(msg)
                 raise ValueError(msg)
 
-            self._cached_prompt = latest_prompt.prompt
-            self._cached_version = latest_prompt.version
+            self._cached_prompt = prompt_text
+            self._cached_version = prompt_version
             self._cache_timestamp = datetime.now(UTC)
 
             logger.info(

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/src/appkit_assistant/components/mcp_server_dialogs.py

@@ -130,7 +130,7 @@ class ValidationState(rx.State):
 @var_operation
 def json(obj: rx.Var, indent: int = 4) -> CustomVarOperationReturn[RETURN]:
     return var_operation_return(
-        js_expression=f"JSON.stringify(JSON.parse({obj}), null, {indent})",
+        js_expression=f"JSON.stringify(JSON.parse({obj} || '{{}}'), null, {indent})",
         var_type=Any,
     )
 

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/src/appkit_assistant/state/mcp_server_state.py

@@ -9,8 +9,9 @@ import reflex as rx
 
 from appkit_assistant.backend.models import MCPServer
 from appkit_assistant.backend.repositories import (
-    MCPServerRepository,
+    mcp_server_repo,
 )
+from appkit_commons.database.session import get_asyncdb_session
 
 logger = logging.getLogger(__name__)
 
@@ -29,7 +30,9 @@ class MCPServerState(rx.State):
         """
         self.loading = True
         try:
-            self.servers = await MCPServerRepository.get_all()
+            async with get_asyncdb_session() as session:
+                servers = await mcp_server_repo.find_all_ordered_by_name(session)
+                self.servers = [MCPServer(**s.model_dump()) for s in servers]
             logger.debug("Loaded %d MCP servers", len(self.servers))
         except Exception as e:
             logger.error("Failed to load MCP servers: %s", e)
@@ -50,7 +53,13 @@ class MCPServerState(rx.State):
     async def get_server(self, server_id: int) -> None:
         """Get a specific MCP server by ID."""
         try:
-            self.current_server = await MCPServerRepository.get_by_id(server_id)
+            async with get_asyncdb_session() as session:
+                server = await mcp_server_repo.find_by_id(session, server_id)
+                if server:
+                    self.current_server = MCPServer(**server.model_dump())
+                else:
+                    self.current_server = None
+
             if not self.current_server:
                 logger.warning("MCP server with ID %d not found", server_id)
         except Exception as e:
@@ -64,7 +73,7 @@ class MCPServerState(rx.State):
         """Add a new MCP server."""
         try:
             headers = self._parse_headers_from_form(form_data)
-            server = await MCPServerRepository.create(
+            server_entity = MCPServer(
                 name=form_data["name"],
                 url=form_data["url"],
                 headers=headers,
@@ -72,12 +81,17 @@ class MCPServerState(rx.State):
                 prompt=form_data.get("prompt") or None,
             )
 
+            async with get_asyncdb_session() as session:
+                server = await mcp_server_repo.save(session, server_entity)
+                # Ensure we have the name before session closes if used later
+                server_name = server.name
+
             await self.load_servers()
             yield rx.toast.info(
                 "MCP Server {} wurde hinzugefügt.".format(form_data["name"]),
                 position="top-right",
             )
-            logger.debug("Added MCP server: %s", server.name)
+            logger.debug("Added MCP server: %s", server_name)
 
         except ValueError as e:
             logger.error("Invalid form data for MCP server: %s", e)
@@ -105,22 +119,34 @@ class MCPServerState(rx.State):
 
         try:
             headers = self._parse_headers_from_form(form_data)
-            updated_server = await MCPServerRepository.update(
-                server_id=self.current_server.id,
-                name=form_data["name"],
-                url=form_data["url"],
-                headers=headers,
-                description=form_data.get("description") or None,
-                prompt=form_data.get("prompt") or None,
-            )
+            updated_name = ""
 
-            if updated_server:
+            async with get_asyncdb_session() as session:
+                # Re-fetch server to ensure we have the latest and bound to session
+                existing_server = await mcp_server_repo.find_by_id(
+                    session, self.current_server.id
+                )
+
+                updated_server = None
+                if existing_server:
+                    existing_server.name = form_data["name"]
+                    existing_server.url = form_data["url"]
+                    existing_server.headers = headers
+                    existing_server.description = form_data.get("description") or None
+                    existing_server.prompt = form_data.get("prompt") or None
+
+                    updated_server = await mcp_server_repo.save(
+                        session, existing_server
+                    )
+                    updated_name = updated_server.name
+
+            if updated_name:
                 await self.load_servers()
                 yield rx.toast.info(
                     "MCP Server {} wurde aktualisiert.".format(form_data["name"]),
                     position="top-right",
                 )
-                logger.debug("Updated MCP server: %s", updated_server.name)
+                logger.debug("Updated MCP server: %s", updated_name)
             else:
                 yield rx.toast.error(
                     "MCP Server konnte nicht gefunden werden.",
@@ -143,19 +169,20 @@ class MCPServerState(rx.State):
     async def delete_server(self, server_id: int) -> AsyncGenerator[Any, Any]:
         """Delete an MCP server."""
         try:
-            # Get server name for the success message
-            server = await MCPServerRepository.get_by_id(server_id)
-            if not server:
-                yield rx.toast.error(
-                    "MCP Server nicht gefunden.",
-                    position="top-right",
-                )
-                return
-
-            server_name = server.name
-
-            # Delete server using repository
-            success = await MCPServerRepository.delete(server_id)
+            async with get_asyncdb_session() as session:
+                # Get server name for the success message
+                server = await mcp_server_repo.find_by_id(session, server_id)
+                if not server:
+                    yield rx.toast.error(
+                        "MCP Server nicht gefunden.",
+                        position="top-right",
+                    )
+                    return
+
+                server_name = server.name
+
+                # Delete server using repository
+                success = await mcp_server_repo.delete_by_id(session, server_id)
 
             if success:
                 await self.load_servers()

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/src/appkit_assistant/state/system_prompt_state.py

@@ -5,8 +5,9 @@ from typing import Any, Final
 import reflex as rx
 from reflex.state import State
 
-from appkit_assistant.backend.repositories import SystemPromptRepository
+from appkit_assistant.backend.repositories import system_prompt_repo
 from appkit_assistant.backend.system_prompt_cache import invalidate_prompt_cache
+from appkit_commons.database.session import get_asyncdb_session
 from appkit_user.authentication.states import UserSession
 
 logger = logging.getLogger(__name__)
@@ -32,31 +33,41 @@ class SystemPromptState(State):
         self.is_loading = True
         self.error_message = ""
         try:
-            prompts = await SystemPromptRepository.get_all()
-            self.versions = [
-                {
-                    "value": str(p.version),
-                    "label": (
-                        f"Version {p.version} - "
-                        f"{p.created_at.strftime('%d.%m.%Y %H:%M')}"
-                    ),
-                }
-                for p in prompts
-            ]
-
-            self.prompt_map = {str(p.version): p.prompt for p in prompts}
-
-            if prompts:
-                latest = prompts[0]
-                self.selected_version_id = latest.version
+            async with get_asyncdb_session() as session:
+                prompts = await system_prompt_repo.find_all_ordered_by_version_desc(
+                    session
+                )
+
+                self.versions = [
+                    {
+                        "value": str(p.version),
+                        "label": (
+                            f"Version {p.version} - "
+                            f"{p.created_at.strftime('%d.%m.%Y %H:%M')}"
+                        ),
+                    }
+                    for p in prompts
+                ]
+
+                self.prompt_map = {str(p.version): p.prompt for p in prompts}
+
+                latest_prompt = None
+                if prompts:
+                    latest_prompt = prompts[0]
+                    # Access attributes to ensure they are loaded/available
+                    self.selected_version_id = latest_prompt.version
+                    latest_prompt_text = latest_prompt.prompt
+                else:
+                    self.selected_version_id = 0
+                    latest_prompt_text = None
 
+            if latest_prompt_text is not None:
                 if not self.current_prompt:
-                    self.current_prompt = latest.prompt
-                    self.last_saved_prompt = latest.prompt
+                    self.current_prompt = latest_prompt_text
+                    self.last_saved_prompt = latest_prompt_text
                 else:
-                    self.last_saved_prompt = latest.prompt
+                    self.last_saved_prompt = latest_prompt_text
             else:
-                self.selected_version_id = 0
                 if not self.current_prompt:
                     self.current_prompt = ""
                 self.last_saved_prompt = self.current_prompt
@@ -93,10 +104,12 @@ class SystemPromptState(State):
             user_session: UserSession = await self.get_state(UserSession)
             user_id = user_session.user_id
 
-            await SystemPromptRepository.create(
-                prompt=self.current_prompt,
-                user_id=user_id,
-            )
+            async with get_asyncdb_session() as session:
+                await system_prompt_repo.create_next_version(
+                    session,
+                    prompt=self.current_prompt,
+                    user_id=user_id,
+                )
 
             self.last_saved_prompt = self.current_prompt
 
@@ -124,7 +137,18 @@ class SystemPromptState(State):
         self.is_loading = True
         self.error_message = ""
         try:
-            success = await SystemPromptRepository.delete(self.selected_version_id)
+            async with get_asyncdb_session() as session:
+                if self.selected_version_id:
+                    prompt = await system_prompt_repo.find_by_id(
+                        session, self.selected_version_id
+                    )
+                    if prompt:
+                        success = await system_prompt_repo.delete(session, prompt)
+                    else:
+                        success = False
+                else:
+                    success = False
+
             if success:
                 self.selected_version_id = 0
 

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/src/appkit_assistant/state/thread_list_state.py

@@ -15,8 +15,9 @@ from typing import TYPE_CHECKING, Any
 
 import reflex as rx
 
-from appkit_assistant.backend.models import ThreadModel
-from appkit_assistant.backend.repositories import ThreadRepository
+from appkit_assistant.backend.models import ThreadModel, ThreadStatus
+from appkit_assistant.backend.repositories import thread_repo
+from appkit_commons.database.session import get_asyncdb_session
 from appkit_user.authentication.states import UserSession
 
 if TYPE_CHECKING:
@@ -124,7 +125,24 @@ class ThreadListState(rx.State):
 
         # Fetch threads from database
         try:
-            threads = await ThreadRepository.get_summaries_by_user(user_id)
+            async with get_asyncdb_session() as session:
+                thread_entities = await thread_repo.find_summaries_by_user(
+                    session, user_id
+                )
+
+                # Convert entities to models inside the session context
+                threads = [
+                    ThreadModel(
+                        thread_id=t.thread_id,
+                        title=t.title,
+                        state=ThreadStatus(t.state),
+                        ai_model=t.ai_model,
+                        active=t.active,
+                        messages=[],
+                    )
+                    for t in thread_entities
+                ]
+
             async with self:
                 self.threads = threads
                 self._initialized = True
@@ -208,7 +226,10 @@ class ThreadListState(rx.State):
 
         try:
             # Delete from database
-            await ThreadRepository.delete_thread(thread_id, user_id)
+            async with get_asyncdb_session() as session:
+                await thread_repo.delete_by_thread_id_and_user(
+                    session, thread_id, user_id
+                )
 
             async with self:
                 # Remove from list

{appkit_assistant-0.13.0 → appkit_assistant-0.14.0}/src/appkit_assistant/state/thread_state.py

@@ -22,6 +22,7 @@ from pydantic import BaseModel
 from appkit_assistant.backend.model_manager import ModelManager
 from appkit_assistant.backend.models import (
     AIModel,
+    AssistantThread,
     Chunk,
     ChunkType,
     MCPServer,
@@ -31,8 +32,9 @@ from appkit_assistant.backend.models import (
     ThreadModel,
     ThreadStatus,
 )
-from appkit_assistant.backend.repositories import MCPServerRepository, ThreadRepository
+from appkit_assistant.backend.repositories import mcp_server_repo, thread_repo
 from appkit_assistant.state.thread_list_state import ThreadListState
+from appkit_commons.database.session import get_asyncdb_session
 from appkit_user.authentication.states import UserSession
 
 logger = logging.getLogger(__name__)
@@ -268,20 +270,41 @@ class ThreadState(rx.State):
             return
 
         try:
-            full_thread = await ThreadRepository.get_thread_by_id(thread_id, user_id)
+            async with get_asyncdb_session() as session:
+                thread_entity = await thread_repo.find_by_thread_id_and_user(
+                    session, thread_id, user_id
+                )
 
-            if not full_thread:
-                logger.warning("Thread %s not found in database", thread_id)
-                async with self:
-                    threadlist_state: ThreadListState = await self.get_state(
-                        ThreadListState
+                if not thread_entity:
+                    logger.warning("Thread %s not found in database", thread_id)
+                    # We can't access self in here easily to clear loading state unless we break out
+                    # but we can check thread_entity after context
+
+                # Convert to ThreadModel if found
+                full_thread = None
+                if thread_entity:
+                    full_thread = ThreadModel(
+                        thread_id=thread_entity.thread_id,
+                        title=thread_entity.title,
+                        state=ThreadStatus(thread_entity.state),
+                        ai_model=thread_entity.ai_model,
+                        active=thread_entity.active,
+                        messages=[Message(**m) for m in thread_entity.messages],
                     )
-                    threadlist_state.loading_thread_id = ""
-                return
+
+            if not full_thread:
+                if not thread_entity:  # it was not found
+                    async with self:
+                        threadlist_state: ThreadListState = await self.get_state(
+                            ThreadListState
+                        )
+                        threadlist_state.loading_thread_id = ""
+                    return
 
             # Mark all messages as done (loaded from DB)
-            for msg in full_thread.messages:
-                msg.done = True
+            if full_thread:
+                for msg in full_thread.messages:
+                    msg.done = True
 
             async with self:
                 # Update self with loaded thread
@@ -355,7 +378,10 @@ class ThreadState(rx.State):
     @rx.event
     async def load_mcp_servers(self) -> None:
         """Load available MCP servers from the database."""
-        self.available_mcp_servers = await MCPServerRepository.get_all()
+        async with get_asyncdb_session() as session:
+            servers = await mcp_server_repo.find_all_ordered_by_name(session)
+            # Create detached copies
+            self.available_mcp_servers = [MCPServer(**s.model_dump()) for s in servers]
 
     @rx.event
     def toogle_tools_modal(self, show: bool) -> None:
@@ -598,7 +624,40 @@ class ThreadState(rx.State):
 
         if user_id:
             try:
-                await ThreadRepository.save_thread(self._thread, user_id)
+                # Prepare entity data
+                messages_dict = [m.dict() for m in self._thread.messages]
+
+                async with get_asyncdb_session() as session:
+                    # Check if exists
+                    existing = await thread_repo.find_by_thread_id_and_user(
+                        session, self._thread.thread_id, user_id
+                    )
+
+                    if existing:
+                        existing.title = self._thread.title
+                        existing.state = (
+                            self._thread.state.value
+                            if hasattr(self._thread.state, "value")
+                            else self._thread.state
+                        )
+                        existing.ai_model = self._thread.ai_model
+                        existing.active = self._thread.active
+                        existing.messages = messages_dict
+                        await thread_repo.save(session, existing)
+                    else:
+                        new_thread = AssistantThread(
+                            thread_id=self._thread.thread_id,
+                            user_id=user_id,
+                            title=self._thread.title,
+                            state=self._thread.state.value
+                            if hasattr(self._thread.state, "value")
+                            else self._thread.state,
+                            ai_model=self._thread.ai_model,
+                            active=self._thread.active,
+                            messages=messages_dict,
+                        )
+                        await thread_repo.save(session, new_thread)
+
                 logger.debug("Saved thread to DB: %s", self._thread.thread_id)
             except Exception as e:
                 logger.error("Error saving thread %s: %s", self._thread.thread_id, e)

appkit_assistant-0.13.0/src/appkit_assistant/backend/repositories.py

@@ -1,323 +0,0 @@
-"""Repository for MCP server data access operations."""
-
-import logging
-from datetime import UTC, datetime
-
-import reflex as rx
-from sqlalchemy.orm import defer
-
-from appkit_assistant.backend.models import (
-    AssistantThread,
-    MCPServer,
-    Message,
-    SystemPrompt,
-    ThreadModel,
-    ThreadStatus,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class MCPServerRepository:
-    """Repository class for MCP server database operations."""
-
-    @staticmethod
-    async def get_all() -> list[MCPServer]:
-        """Retrieve all MCP servers ordered by name."""
-        async with rx.asession() as session:
-            result = await session.exec(MCPServer.select().order_by(MCPServer.name))
-            return result.all()
-
-    @staticmethod
-    async def get_by_id(server_id: int) -> MCPServer | None:
-        """Retrieve an MCP server by ID."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                MCPServer.select().where(MCPServer.id == server_id)
-            )
-            return result.first()
-
-    @staticmethod
-    async def create(
-        name: str,
-        url: str,
-        headers: str,
-        description: str | None = None,
-        prompt: str | None = None,
-    ) -> MCPServer:
-        """Create a new MCP server."""
-        async with rx.asession() as session:
-            server = MCPServer(
-                name=name,
-                url=url,
-                headers=headers,
-                description=description,
-                prompt=prompt,
-            )
-            session.add(server)
-            await session.commit()
-            await session.refresh(server)
-            logger.debug("Created MCP server: %s", name)
-            return server
-
-    @staticmethod
-    async def update(
-        server_id: int,
-        name: str,
-        url: str,
-        headers: str,
-        description: str | None = None,
-        prompt: str | None = None,
-    ) -> MCPServer | None:
-        """Update an existing MCP server."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                MCPServer.select().where(MCPServer.id == server_id)
-            )
-            server = result.first()
-            if server:
-                server.name = name
-                server.url = url
-                server.headers = headers
-                server.description = description
-                server.prompt = prompt
-                await session.commit()
-                await session.refresh(server)
-                logger.debug("Updated MCP server: %s", name)
-                return server
-            logger.warning("MCP server with ID %s not found for update", server_id)
-            return None
-
-    @staticmethod
-    async def delete(server_id: int) -> bool:
-        """Delete an MCP server by ID."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                MCPServer.select().where(MCPServer.id == server_id)
-            )
-            server = result.first()
-            if server:
-                await session.delete(server)
-                await session.commit()
-                logger.debug("Deleted MCP server: %s", server.name)
-                return True
-            logger.warning("MCP server with ID %s not found for deletion", server_id)
-            return False
-
-
-class SystemPromptRepository:
-    """Repository class for system prompt database operations.
-
-    Implements append-only versioning with full CRUD capabilities.
-    """
-
-    @staticmethod
-    async def get_all() -> list[SystemPrompt]:
-        """Retrieve all system prompt versions ordered by version descending."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                SystemPrompt.select().order_by(SystemPrompt.version.desc())
-            )
-            return result.all()
-
-    @staticmethod
-    async def get_latest() -> SystemPrompt | None:
-        """Retrieve the latest system prompt version."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                SystemPrompt.select().order_by(SystemPrompt.version.desc()).limit(1)
-            )
-            return result.first()
-
-    @staticmethod
-    async def get_by_id(prompt_id: int) -> SystemPrompt | None:
-        """Retrieve a system prompt by ID."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                SystemPrompt.select().where(SystemPrompt.id == prompt_id)
-            )
-            return result.first()
-
-    @staticmethod
-    async def create(prompt: str, user_id: int) -> SystemPrompt:
-        """Neue System Prompt Version anlegen.
-
-        Version ist fortlaufende Ganzzahl, beginnend bei 1.
-        """
-        async with rx.asession() as session:
-            result = await session.exec(
-                SystemPrompt.select().order_by(SystemPrompt.version.desc()).limit(1)
-            )
-            latest = result.first()
-            next_version = (latest.version + 1) if latest else 1
-
-            name = f"Version {next_version}"
-
-            system_prompt = SystemPrompt(
-                name=name,
-                prompt=prompt,
-                version=next_version,
-                user_id=user_id,
-                created_at=datetime.now(UTC),
-            )
-            session.add(system_prompt)
-            await session.commit()
-            await session.refresh(system_prompt)
-
-            logger.info(
-                "Created system prompt version %s for user %s",
-                next_version,
-                user_id,
-            )
-            return system_prompt
-
-    @staticmethod
-    async def delete(prompt_id: int) -> bool:
-        """Delete a system prompt version by ID."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                SystemPrompt.select().where(SystemPrompt.id == prompt_id)
-            )
-            prompt = result.first()
-            if prompt:
-                await session.delete(prompt)
-                await session.commit()
-                logger.info("Deleted system prompt version: %s", prompt.version)
-                return True
-            logger.warning(
-                "System prompt with ID %s not found for deletion",
-                prompt_id,
-            )
-            return False
-
-
-class ThreadRepository:
-    """Repository class for Thread database operations."""
-
-    @staticmethod
-    async def get_by_user(user_id: int) -> list[ThreadModel]:
-        """Retrieve all threads for a user."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                AssistantThread.select()
-                .where(AssistantThread.user_id == user_id)
-                .order_by(AssistantThread.updated_at.desc())
-            )
-            threads = result.all()
-            return [
-                ThreadModel(
-                    thread_id=t.thread_id,
-                    title=t.title,
-                    state=ThreadStatus(t.state),
-                    ai_model=t.ai_model,
-                    active=t.active,
-                    messages=[Message(**m) for m in t.messages],
-                )
-                for t in threads
-            ]
-
-    @staticmethod
-    async def save_thread(thread: ThreadModel, user_id: int) -> None:
-        """Save or update a thread."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                AssistantThread.select().where(
-                    AssistantThread.thread_id == thread.thread_id
-                )
-            )
-            db_thread = result.first()
-
-            messages_dict = [m.dict() for m in thread.messages]
-
-            if db_thread:
-                # Ensure user owns the thread or handle shared threads logic if needed
-                # For now, we assume thread_id is unique enough,
-                # but checking user_id is safer
-                if db_thread.user_id != user_id:
-                    logger.warning(
-                        "User %s tried to update thread %s belonging to user %s",
-                        user_id,
-                        thread.thread_id,
-                        db_thread.user_id,
-                    )
-                    return
-
-                db_thread.title = thread.title
-                db_thread.state = thread.state.value
-                db_thread.ai_model = thread.ai_model
-                db_thread.active = thread.active
-                db_thread.messages = messages_dict
-                session.add(db_thread)
-            else:
-                db_thread = AssistantThread(
-                    thread_id=thread.thread_id,
-                    user_id=user_id,
-                    title=thread.title,
-                    state=thread.state.value,
-                    ai_model=thread.ai_model,
-                    active=thread.active,
-                    messages=messages_dict,
-                )
-                session.add(db_thread)
-
-            await session.commit()
-
-    @staticmethod
-    async def delete_thread(thread_id: str, user_id: int) -> None:
-        """Delete a thread."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                AssistantThread.select().where(
-                    AssistantThread.thread_id == thread_id,
-                    AssistantThread.user_id == user_id,
-                )
-            )
-            thread = result.first()
-            if thread:
-                await session.delete(thread)
-                await session.commit()
-
-    @staticmethod
-    async def get_summaries_by_user(user_id: int) -> list[ThreadModel]:
-        """Retrieve thread summaries (no messages) for a user."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                AssistantThread.select()
-                .where(AssistantThread.user_id == user_id)
-                .options(defer(AssistantThread.messages))
-                .order_by(AssistantThread.updated_at.desc())
-            )
-            threads = result.all()
-            return [
-                ThreadModel(
-                    thread_id=t.thread_id,
-                    title=t.title,
-                    state=ThreadStatus(t.state),
-                    ai_model=t.ai_model,
-                    active=t.active,
-                    messages=[],  # Empty messages for summary
-                )
-                for t in threads
-            ]
-
-    @staticmethod
-    async def get_thread_by_id(thread_id: str, user_id: int) -> ThreadModel | None:
-        """Retrieve a full thread by ID."""
-        async with rx.asession() as session:
-            result = await session.exec(
-                AssistantThread.select().where(
-                    AssistantThread.thread_id == thread_id,
-                    AssistantThread.user_id == user_id,
-                )
-            )
-            t = result.first()
-            if not t:
-                return None
-            return ThreadModel(
-                thread_id=t.thread_id,
-                title=t.title,
-                state=ThreadStatus(t.state),
-                ai_model=t.ai_model,
-                active=t.active,
-                messages=[Message(**m) for m in t.messages],
-            )