spaik-sdk 0.6.2__py3-none-any.whl

spaik_sdk/server/storage/impl/local_file_thread_repository.py

@@ -0,0 +1,217 @@
+import json
+import pickle
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from spaik_sdk.server.storage.base_thread_repository import BaseThreadRepository
+from spaik_sdk.server.storage.thread_filter import ThreadFilter
+from spaik_sdk.server.storage.thread_metadata import ThreadMetadata
+from spaik_sdk.thread.models import ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class LocalFileThreadRepository(BaseThreadRepository):
+    """Local file-based implementation of thread repository for development"""
+
+    def __init__(self, data_dir: str = "data"):
+        self.data_dir = Path(data_dir)
+        self.threads_dir = self.data_dir / "threads"
+        self.metadata_file = self.data_dir / "metadata.json"
+
+        # Create directories if they don't exist
+        self.threads_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load metadata cache
+        self._metadata_cache: Dict[str, ThreadMetadata] = {}
+        self._load_metadata_cache()
+
+    def _load_metadata_cache(self) -> None:
+        """Load metadata from disk into memory cache"""
+        if self.metadata_file.exists():
+            try:
+                with open(self.metadata_file, "r") as f:
+                    data = json.load(f)
+                    # Convert dict to ThreadMetadata objects
+                    metadata_cache = {}
+                    for thread_id, metadata_dict in data.items():
+                        if isinstance(metadata_dict, dict):
+                            # Create ThreadMetadata with explicit arguments to satisfy type checker
+                            metadata_cache[thread_id] = ThreadMetadata(
+                                thread_id=metadata_dict.get("thread_id", thread_id),
+                                title=metadata_dict.get("title", "New Thread"),
+                                message_count=metadata_dict.get("message_count", 0),
+                                last_activity_time=metadata_dict.get("last_activity_time", 0),
+                                created_at=metadata_dict.get("created_at", 0),
+                                author_id=metadata_dict.get("author_id", "unknown"),
+                                type=metadata_dict.get("type", "chat"),
+                            )
+                    self._metadata_cache = metadata_cache
+            except (json.JSONDecodeError, TypeError, KeyError):
+                # If metadata is corrupted, rebuild it
+                self._rebuild_metadata_cache()
+
+    def _save_metadata_cache(self) -> None:
+        """Save metadata cache to disk"""
+        data = {
+            thread_id: {
+                "thread_id": metadata.thread_id,
+                "title": metadata.title,
+                "message_count": metadata.message_count,
+                "last_activity_time": metadata.last_activity_time,
+                "created_at": metadata.created_at,
+                "author_id": metadata.author_id,
+                "type": metadata.type,
+            }
+            for thread_id, metadata in self._metadata_cache.items()
+        }
+
+        with open(self.metadata_file, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def _rebuild_metadata_cache(self) -> None:
+        """Rebuild metadata cache by reading all thread files"""
+        self._metadata_cache.clear()
+
+        for thread_file in self.threads_dir.glob("*.pkl"):
+            thread_id = thread_file.stem
+            try:
+                thread = self._load_thread_from_file(thread_id)
+                if thread:
+                    metadata = ThreadMetadata.from_thread_container(thread)
+                    self._metadata_cache[thread_id] = metadata
+            except Exception:
+                # Skip corrupted files
+                continue
+
+        self._save_metadata_cache()
+
+    def _thread_file_path(self, thread_id: str) -> Path:
+        """Get file path for a thread"""
+        return self.threads_dir / f"{thread_id}.pkl"
+
+    def _load_thread_from_file(self, thread_id: str) -> Optional[ThreadContainer]:
+        """Load thread from pickle file"""
+        file_path = self._thread_file_path(thread_id)
+        if not file_path.exists():
+            return None
+
+        try:
+            with open(file_path, "rb") as f:
+                return pickle.load(f)
+        except (pickle.PickleError, EOFError, OSError):
+            return None
+
+    def _save_thread_to_file(self, thread: ThreadContainer) -> None:
+        """Save thread to pickle file"""
+        file_path = self._thread_file_path(thread.thread_id)
+
+        # Create a serializable copy to avoid issues with non-picklable subscribers
+        serializable_thread = thread.create_serializable_copy()
+
+        with open(file_path, "wb") as f:
+            pickle.dump(serializable_thread, f)
+
+    async def save_thread(self, thread_container: ThreadContainer) -> None:
+        """Save complete thread container to disk"""
+        self._save_thread_to_file(thread_container)
+
+        # Update metadata cache
+        metadata = ThreadMetadata.from_thread_container(thread_container)
+        self._metadata_cache[thread_container.thread_id] = metadata
+        self._save_metadata_cache()
+
+    async def load_thread(self, thread_id: str) -> Optional[ThreadContainer]:
+        """Load thread container from disk"""
+        return self._load_thread_from_file(thread_id)
+
+    async def get_message(self, thread_id: str, message_id: str) -> Optional[ThreadMessage]:
+        """Get message from disk"""
+        thread = await self.load_thread(thread_id)
+        if not thread:
+            return None
+
+        for message in thread.messages:
+            if message.id == message_id:
+                return message
+        return None
+
+    async def upsert_message(self, thread_id: str, message: ThreadMessage) -> None:
+        """Upsert message to disk"""
+        thread = await self.load_thread(thread_id)
+        if not thread:
+            return
+
+        # Find existing message and replace, or add new one
+        for i, existing_msg in enumerate(thread.messages):
+            if existing_msg.id == message.id:
+                thread.messages[i] = message
+                break
+        else:
+            thread.messages.append(message)
+
+        # Save updated thread
+        await self.save_thread(thread)
+
+    async def delete_message(self, thread_id: str, message_id: str) -> None:
+        """Delete message from disk"""
+        thread = await self.load_thread(thread_id)
+        if not thread:
+            return
+
+        thread.messages = [msg for msg in thread.messages if msg.id != message_id]
+
+        # Save updated thread
+        await self.save_thread(thread)
+
+    async def thread_exists(self, thread_id: str) -> bool:
+        """Check if thread exists on disk"""
+        return self._thread_file_path(thread_id).exists()
+
+    async def delete_thread(self, thread_id: str) -> bool:
+        """Delete thread and all its messages from disk"""
+        file_path = self._thread_file_path(thread_id)
+
+        if file_path.exists():
+            try:
+                file_path.unlink()  # Delete file
+
+                # Remove from metadata cache
+                if thread_id in self._metadata_cache:
+                    del self._metadata_cache[thread_id]
+                    self._save_metadata_cache()
+
+                return True
+            except OSError:
+                return False
+        return False
+
+    async def list_threads(self, filter: ThreadFilter) -> List[ThreadMetadata]:
+        """List threads matching the filter from disk metadata"""
+        result = []
+
+        for metadata in self._metadata_cache.values():
+            if filter.matches(metadata):
+                result.append(metadata)
+
+        # Sort by last activity time (most recent first)
+        result.sort(key=lambda x: x.last_activity_time, reverse=True)
+        return result
+
+    def clear_all(self) -> None:
+        """Clear all data from disk (useful for testing)"""
+        # Remove all thread files
+        for thread_file in self.threads_dir.glob("*.pkl"):
+            thread_file.unlink()
+
+        # Clear metadata
+        self._metadata_cache.clear()
+        if self.metadata_file.exists():
+            self.metadata_file.unlink()
+
+    def get_thread_count(self) -> int:
+        """Get total number of threads stored"""
+        return len(self._metadata_cache)
+
+    def get_data_dir(self) -> Path:
+        """Get the data directory path"""
+        return self.data_dir

spaik_sdk/server/storage/thread_filter.py

@@ -0,0 +1,166 @@
+from dataclasses import dataclass
+from typing import List, Optional, Set
+
+from spaik_sdk.server.storage.thread_metadata import ThreadMetadata
+
+
+@dataclass
+class ThreadFilter:
+    """Filter for thread metadata with fluent builder interface"""
+
+    thread_ids: Optional[Set[str]] = None
+    author_ids: Optional[Set[str]] = None
+    types: Optional[Set[str]] = None
+    title_contains: Optional[str] = None
+    min_message_count: Optional[int] = None
+    max_message_count: Optional[int] = None
+    min_last_activity: Optional[int] = None
+    max_last_activity: Optional[int] = None
+    min_created_at: Optional[int] = None
+    max_created_at: Optional[int] = None
+
+    @classmethod
+    def builder(cls) -> "ThreadFilterBuilder":
+        """Create a new filter builder"""
+        return ThreadFilterBuilder()
+
+    def matches(self, metadata: ThreadMetadata) -> bool:
+        """Check if thread metadata matches all filter criteria"""
+
+        if self.thread_ids is not None and metadata.thread_id not in self.thread_ids:
+            return False
+
+        if self.author_ids is not None and metadata.author_id not in self.author_ids:
+            return False
+
+        if self.types is not None and metadata.type not in self.types:
+            return False
+
+        if self.title_contains is not None and self.title_contains.lower() not in metadata.title.lower():
+            return False
+
+        if self.min_message_count is not None and metadata.message_count < self.min_message_count:
+            return False
+
+        if self.max_message_count is not None and metadata.message_count > self.max_message_count:
+            return False
+
+        if self.min_last_activity is not None and metadata.last_activity_time < self.min_last_activity:
+            return False
+
+        if self.max_last_activity is not None and metadata.last_activity_time > self.max_last_activity:
+            return False
+
+        if self.min_created_at is not None and metadata.created_at < self.min_created_at:
+            return False
+
+        if self.max_created_at is not None and metadata.created_at > self.max_created_at:
+            return False
+
+        return True
+
+
+class ThreadFilterBuilder:
+    """Fluent builder for ThreadFilter"""
+
+    def __init__(self):
+        self._filter = ThreadFilter()
+
+    def with_thread_id(self, thread_id: str) -> "ThreadFilterBuilder":
+        """Filter by specific thread ID"""
+        if self._filter.thread_ids is None:
+            self._filter.thread_ids = set()
+        self._filter.thread_ids.add(thread_id)
+        return self
+
+    def with_thread_ids(self, thread_ids: List[str]) -> "ThreadFilterBuilder":
+        """Filter by multiple thread IDs"""
+        if self._filter.thread_ids is None:
+            self._filter.thread_ids = set()
+        self._filter.thread_ids.update(thread_ids)
+        return self
+
+    def with_author_id(self, author_id: str) -> "ThreadFilterBuilder":
+        """Filter by specific author ID"""
+        if self._filter.author_ids is None:
+            self._filter.author_ids = set()
+        self._filter.author_ids.add(author_id)
+        return self
+
+    def with_author_ids(self, author_ids: List[str]) -> "ThreadFilterBuilder":
+        """Filter by multiple author IDs"""
+        if self._filter.author_ids is None:
+            self._filter.author_ids = set()
+        self._filter.author_ids.update(author_ids)
+        return self
+
+    def with_type(self, thread_type: str) -> "ThreadFilterBuilder":
+        """Filter by specific thread type"""
+        if self._filter.types is None:
+            self._filter.types = set()
+        self._filter.types.add(thread_type)
+        return self
+
+    def with_types(self, thread_types: List[str]) -> "ThreadFilterBuilder":
+        """Filter by multiple thread types"""
+        if self._filter.types is None:
+            self._filter.types = set()
+        self._filter.types.update(thread_types)
+        return self
+
+    def with_title_containing(self, text: str) -> "ThreadFilterBuilder":
+        """Filter by title containing text (case insensitive)"""
+        self._filter.title_contains = text
+        return self
+
+    def with_min_messages(self, min_count: int) -> "ThreadFilterBuilder":
+        """Filter threads with at least this many messages"""
+        self._filter.min_message_count = min_count
+        return self
+
+    def with_max_messages(self, max_count: int) -> "ThreadFilterBuilder":
+        """Filter threads with at most this many messages"""
+        self._filter.max_message_count = max_count
+        return self
+
+    def with_message_count_range(self, min_count: int, max_count: int) -> "ThreadFilterBuilder":
+        """Filter threads with message count in range [min_count, max_count]"""
+        self._filter.min_message_count = min_count
+        self._filter.max_message_count = max_count
+        return self
+
+    def with_activity_after(self, timestamp: int) -> "ThreadFilterBuilder":
+        """Filter threads with last activity after timestamp (UTC millis)"""
+        self._filter.min_last_activity = timestamp
+        return self
+
+    def with_activity_before(self, timestamp: int) -> "ThreadFilterBuilder":
+        """Filter threads with last activity before timestamp (UTC millis)"""
+        self._filter.max_last_activity = timestamp
+        return self
+
+    def with_activity_range(self, start: int, end: int) -> "ThreadFilterBuilder":
+        """Filter threads with last activity in range [start, end] (UTC millis)"""
+        self._filter.min_last_activity = start
+        self._filter.max_last_activity = end
+        return self
+
+    def with_created_after(self, timestamp: int) -> "ThreadFilterBuilder":
+        """Filter threads created after timestamp (UTC millis)"""
+        self._filter.min_created_at = timestamp
+        return self
+
+    def with_created_before(self, timestamp: int) -> "ThreadFilterBuilder":
+        """Filter threads created before timestamp (UTC millis)"""
+        self._filter.max_created_at = timestamp
+        return self
+
+    def with_created_range(self, start: int, end: int) -> "ThreadFilterBuilder":
+        """Filter threads created in range [start, end] (UTC millis)"""
+        self._filter.min_created_at = start
+        self._filter.max_created_at = end
+        return self
+
+    def build(self) -> ThreadFilter:
+        """Build the final filter"""
+        return self._filter

spaik_sdk/server/storage/thread_metadata.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass
+
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+@dataclass
+class ThreadMetadata:
+    thread_id: str
+    title: str
+    message_count: int
+    last_activity_time: int
+    created_at: int
+    author_id: str
+    type: str
+
+    @classmethod
+    def from_thread_container(cls, thread: ThreadContainer, thread_type: str = "chat") -> "ThreadMetadata":
+        """Create ThreadMetadata from a ThreadContainer"""
+
+        # Extract title from first user message or fallback to system prompt
+        title = "New Thread"
+        first_user_message = None
+
+        # Find first non-AI message for title and author
+        for msg in thread.messages:
+            if not msg.ai:
+                first_user_message = msg
+                content = msg.get_text_content().strip()
+                if content:
+                    # Use first 50 chars as title
+                    title = content[:50] + ("..." if len(content) > 50 else "")
+                break
+
+        # Fallback to system prompt for title if no user message
+        if title == "New Thread" and thread.system_prompt:
+            prompt_preview = thread.system_prompt[:50]
+            title = f"System: {prompt_preview}" + ("..." if len(thread.system_prompt) > 50 else "")
+
+        # Extract author_id from first user message or default
+        author_id = first_user_message.author_id if first_user_message else "unknown"
+
+        # Use first message timestamp as created_at, or current time if no messages
+        created_at = thread.messages[0].timestamp if thread.messages else thread.get_last_activity_time()
+
+        return cls(
+            thread_id=thread.thread_id,
+            title=title,
+            message_count=len(thread.messages),
+            last_activity_time=thread.get_last_activity_time(),
+            created_at=created_at,
+            author_id=author_id,
+            type=thread_type,
+        )

spaik_sdk/thread/adapters/cli/block_display.py

@@ -0,0 +1,92 @@
+import time
+from enum import Enum
+from typing import Optional
+
+from rich.panel import Panel
+from rich.text import Text
+
+
+class BlockDisplayType(Enum):
+    REASONING = "reasoning"
+    RESPONSE = "response"
+    TOOL_CALL = "tool_call"
+    ERROR = "error"
+
+
+class BlockDisplay:
+    """Represents a displayable block with content and styling info"""
+
+    def __init__(
+        self,
+        block_id: str,
+        display_type: BlockDisplayType,
+        content: str = "",
+        streaming: bool = False,
+        tool_name: Optional[str] = None,
+        tool_error: Optional[str] = None,
+    ):
+        self.block_id = block_id
+        self.display_type = display_type
+        self.content = content
+        self.streaming = streaming
+        self.tool_name = tool_name
+        self.tool_error = tool_error
+        self.created_at = time.time()
+
+    def to_panel(self) -> Panel:
+        """Convert this block to a Rich Panel"""
+        if self.display_type == BlockDisplayType.REASONING:
+            text = Text()
+            text.append("🧠 ", style="blue bold")
+            display_content = self.content[:400] + ("..." if len(self.content) > 400 else "")
+            if self.streaming:
+                text.append(display_content, style="blue")
+            else:
+                text.append(display_content)
+
+            title = "AI Thinking" + (" 🌊" if self.streaming else " ✅")
+            return Panel(text, title=title, border_style="blue")
+
+        elif self.display_type == BlockDisplayType.RESPONSE:
+            text = Text()
+            text.append("🤖 ", style="green bold")
+            text.append(self.content)
+
+            title = f"Response ({self.block_id[:8]})" + (" 🌊" if self.streaming else " ✅")
+            return Panel(text, title=title, border_style="green")
+
+        elif self.display_type == BlockDisplayType.TOOL_CALL:
+            text = Text()
+            text.append("🔧 ", style="yellow bold")
+            text.append(f"{self.tool_name or 'unknown'}", style="yellow")
+
+            if self.streaming:
+                text.append(" (running...)", style="bright_black")
+            elif self.tool_error:
+                text.append(f"\n\n→ Error:\n{self.tool_error}", style="red")
+                title = f"Tool: {self.tool_name} ❌"
+                border_style = "red"
+            elif self.content:
+                result = self.content[:200] + ("..." if len(self.content) > 200 else "")
+                text.append(f"\n\n→ Result:\n{result}", style="green")
+                title = f"Tool: {self.tool_name} ✅"
+                border_style = "green"
+            else:
+                title = f"Tool: {self.tool_name} ⏳"
+                border_style = "bright_black"
+
+            if self.streaming:
+                title = f"Tool: {self.tool_name} 🌊"
+                border_style = "yellow"
+            elif not hasattr(locals(), "title"):
+                title = f"Tool: {self.tool_name} ⏳"
+                border_style = "bright_black"
+
+            return Panel(text, title=title, border_style=border_style)
+
+        elif self.display_type == BlockDisplayType.ERROR:
+            text = Text()
+            text.append("❌ Error", style="red bold")
+            return Panel(text, title="Error", border_style="red")
+
+        return Panel("Unknown block type")

spaik_sdk/thread/adapters/cli/display_manager.py

@@ -0,0 +1,84 @@
+from typing import Dict, Optional
+
+from rich.console import Console, Group
+from rich.live import Live
+from rich.text import Text
+
+from spaik_sdk.thread.adapters.cli.block_display import BlockDisplay, BlockDisplayType
+
+
+class DisplayManager:
+    """Manages Rich component mappings and targeted updates"""
+
+    def __init__(self):
+        self.console = Console()
+        self.live: Optional[Live] = None
+        self.blocks: Dict[str, BlockDisplay] = {}  # block_id -> BlockDisplay
+        self._running = False
+
+    def start(self):
+        """Start live display"""
+        if self._running:
+            return
+
+        self._running = True
+
+        self.live = Live(self._create_initial_display(), console=self.console, refresh_per_second=10)
+        self.live.start()
+
+    def stop(self):
+        """Stop live display"""
+        if not self._running:
+            return
+
+        self._running = False
+        self.blocks = {}
+        if self.live:
+            try:
+                self.live.stop()
+            except (BlockingIOError, OSError):
+                # Rich display cleanup failed, but that's ok
+                # This can happen when stdout buffer is full/blocked
+                pass
+
+    def _create_initial_display(self):
+        """Create the initial display"""
+        return Text("Waiting for activity...")
+
+    def update_block_content(self, block_id: str, content: Optional[str] = None, streaming: bool = False):
+        """Update a block's content"""
+        if block_id in self.blocks:
+            if content:
+                self.blocks[block_id].content = content
+            self.blocks[block_id].streaming = streaming
+            self._refresh_display()
+
+    def update_tool_result(self, block_id: str, result: str, error: Optional[str] = None):
+        """Update a tool block's result"""
+        if block_id in self.blocks:
+            if error:
+                self.blocks[block_id].tool_error = error
+            else:
+                self.blocks[block_id].content = result
+            self.blocks[block_id].streaming = False
+            self._refresh_display()
+
+    def add_block(
+        self, block_id: str, display_type: BlockDisplayType, content: str = "", streaming: bool = False, tool_name: Optional[str] = None
+    ):
+        """Add a new block"""
+        self.blocks[block_id] = BlockDisplay(
+            block_id=block_id, display_type=display_type, content=content, streaming=streaming, tool_name=tool_name
+        )
+        self._refresh_display()
+
+    def _refresh_display(self):
+        """Refresh the live display with current panels"""
+        if not self.live:
+            return
+
+        panels = [block.to_panel() for block in self.blocks.values()]
+        if panels:
+            self.live.update(Group(*panels))
+        else:
+            self.live.update(Text("Waiting for activity..."))