sqlsaber 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

sqlsaber/agents/anthropic.py

@@ -450,6 +450,16 @@ Guidelines:
         self._last_query = None
 
         try:
+            # Ensure conversation is active for persistence
+            await self._ensure_conversation()
+
+            # Store user message in conversation history and persistence
+            if use_history:
+                self.conversation_history.append(
+                    {"role": "user", "content": user_query}
+                )
+                await self._store_user_message(user_query)
+
             # Build messages with history if requested
             messages = []
             if use_history:
@@ -461,8 +471,9 @@ Guidelines:
                 instructions = self._get_sql_assistant_instructions()
                 messages.append(Message(MessageRole.USER, instructions))
 
-            # Add current user message
-            messages.append(Message(MessageRole.USER, user_query))
+            # Add current user message if not already in messages from history
+            if not use_history:
+                messages.append(Message(MessageRole.USER, user_query))
 
             # Create initial request and get response
             request = self._create_message_request(messages)
@@ -484,9 +495,12 @@ Guidelines:
                     return
 
                 # Add assistant's response to conversation
-                collected_content.append(
-                    {"role": "assistant", "content": response.content}
-                )
+                assistant_content = {"role": "assistant", "content": response.content}
+                collected_content.append(assistant_content)
+
+                # Store the assistant message immediately (not from collected_content)
+                if use_history:
+                    await self._store_assistant_message(response.content)
 
                 # Execute tools and get results
                 tool_results = []
@@ -499,9 +513,19 @@ Guidelines:
                         tool_results = event
 
                 # Continue conversation with tool results
-                collected_content.append({"role": "user", "content": tool_results})
+                tool_content = {"role": "user", "content": tool_results}
+                collected_content.append(tool_content)
+
+                # Store the tool message immediately and update history
                 if use_history:
-                    self.conversation_history.extend(collected_content)
+                    # Only add the NEW messages to history (not the accumulated ones)
+                    # collected_content has [assistant1, tool1, assistant2, tool2, ...]
+                    # We only want to add the last 2 items that were just added
+                    new_messages_for_history = collected_content[
+                        -2:
+                    ]  # Last assistant + tool pair
+                    self.conversation_history.extend(new_messages_for_history)
+                    await self._store_tool_message(tool_results)
 
                 if cancellation_token is not None and cancellation_token.is_set():
                     return
@@ -541,6 +565,10 @@ Guidelines:
                     {"role": "assistant", "content": response.content}
                 )
 
+                # Store final assistant message in persistence (only if not tool_use)
+                if response.stop_reason != "tool_use":
+                    await self._store_assistant_message(response.content)
+
         except asyncio.CancelledError:
             return
         except Exception as e:

sqlsaber/agents/base.py

@@ -7,6 +7,7 @@ from typing import Any, AsyncIterator
 
 from uniplot import histogram, plot
 
+from sqlsaber.conversation.manager import ConversationManager
 from sqlsaber.database.connection import (
     BaseDatabaseConnection,
     CSVConnection,
@@ -26,6 +27,11 @@ class BaseSQLAgent(ABC):
         self.schema_manager = SchemaManager(db_connection)
         self.conversation_history: list[dict[str, Any]] = []
 
+        # Conversation persistence
+        self._conv_manager = ConversationManager()
+        self._conversation_id: str | None = None
+        self._msg_index: int = 0
+
     @abstractmethod
     async def query_stream(
         self,
@@ -42,8 +48,12 @@ class BaseSQLAgent(ABC):
         """
         pass
 
-    def clear_history(self):
+    async def clear_history(self):
         """Clear conversation history."""
+        # End current conversation in storage
+        await self._end_conversation()
+
+        # Clear in-memory history
         self.conversation_history = []
 
     def _get_database_type_name(self) -> str:
@@ -284,3 +294,96 @@ class BaseSQLAgent(ABC):
 
         except Exception as e:
             return json.dumps({"error": f"Error creating plot: {str(e)}"})
+
+    # Conversation persistence helpers
+
+    async def _ensure_conversation(self) -> None:
+        """Ensure a conversation is active for storing messages."""
+        if self._conversation_id is None:
+            db_name = getattr(self, "database_name", "unknown")
+            self._conversation_id = await self._conv_manager.start_conversation(db_name)
+            self._msg_index = 0
+
+    async def _store_user_message(self, content: str | dict[str, Any]) -> None:
+        """Store a user message in conversation history."""
+        if self._conversation_id is None:
+            return
+
+        await self._conv_manager.add_user_message(
+            self._conversation_id, content, self._msg_index
+        )
+        self._msg_index += 1
+
+    async def _store_assistant_message(
+        self, content: list[dict[str, Any]] | dict[str, Any]
+    ) -> None:
+        """Store an assistant message in conversation history."""
+        if self._conversation_id is None:
+            return
+
+        await self._conv_manager.add_assistant_message(
+            self._conversation_id, content, self._msg_index
+        )
+        self._msg_index += 1
+
+    async def _store_tool_message(
+        self, content: list[dict[str, Any]] | dict[str, Any]
+    ) -> None:
+        """Store a tool/system message in conversation history."""
+        if self._conversation_id is None:
+            return
+
+        await self._conv_manager.add_tool_message(
+            self._conversation_id, content, self._msg_index
+        )
+        self._msg_index += 1
+
+    async def _end_conversation(self) -> None:
+        """End the current conversation."""
+        if self._conversation_id:
+            await self._conv_manager.end_conversation(self._conversation_id)
+        self._conversation_id = None
+        self._msg_index = 0
+
+    async def restore_conversation(self, conversation_id: str) -> bool:
+        """Restore a conversation from storage to in-memory history.
+
+        Args:
+            conversation_id: ID of the conversation to restore
+
+        Returns:
+            True if successfully restored, False otherwise
+        """
+        success = await self._conv_manager.restore_conversation_to_agent(
+            conversation_id, self.conversation_history
+        )
+
+        if success:
+            # Set up for continuing this conversation
+            self._conversation_id = conversation_id
+            self._msg_index = len(self.conversation_history)
+
+        return success
+
+    async def list_conversations(self, limit: int = 50) -> list:
+        """List conversations for this agent's database.
+
+        Args:
+            limit: Maximum number of conversations to return
+
+        Returns:
+            List of conversation data
+        """
+        db_name = getattr(self, "database_name", None)
+        conversations = await self._conv_manager.list_conversations(db_name, limit)
+
+        return [
+            {
+                "id": conv.id,
+                "database_name": conv.database_name,
+                "started_at": conv.formatted_start_time(),
+                "ended_at": conv.formatted_end_time(),
+                "duration": conv.duration_seconds(),
+            }
+            for conv in conversations
+        ]

sqlsaber/cli/commands.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import sys
-from pathlib import Path
 from typing import Annotated
 
 import cyclopts
@@ -17,6 +16,7 @@ from sqlsaber.cli.models import create_models_app
 from sqlsaber.cli.streaming import StreamingQueryHandler
 from sqlsaber.config.database import DatabaseConfigManager
 from sqlsaber.database.connection import DatabaseConnection
+from sqlsaber.database.resolver import DatabaseResolutionError, resolve_database
 
 
 class CLIError(Exception):
@@ -43,7 +43,7 @@ def meta_handler(
         str | None,
         cyclopts.Parameter(
             ["--database", "-d"],
-            help="Database connection name or direct file path for CSV/SQLite files (uses default if not specified)",
+            help="Database connection name, file path (CSV/SQLite), or connection string (postgresql://, mysql://) (uses default if not specified)",
         ),
     ] = None,
 ):
@@ -56,6 +56,8 @@ def meta_handler(
         saber -d mydb "show me users"          # Run a query with specific database
         saber -d data.csv "show me users"      # Run a query with ad-hoc CSV file
         saber -d data.db "show me users"       # Run a query with ad-hoc SQLite file
+        saber -d "postgresql://user:pass@host:5432/db" "show users"  # PostgreSQL connection string
+        saber -d "mysql://user:pass@host:3306/db" "show users"       # MySQL connection string
         echo "show me all users" | saber       # Read query from stdin
         cat query.txt | saber                  # Read query from file via stdin
     """
@@ -75,7 +77,7 @@ def query(
         str | None,
         cyclopts.Parameter(
             ["--database", "-d"],
-            help="Database connection name or direct file path for CSV/SQLite files (uses default if not specified)",
+            help="Database connection name, file path (CSV/SQLite), or connection string (postgresql://, mysql://) (uses default if not specified)",
         ),
     ] = None,
 ):
@@ -92,6 +94,8 @@ def query(
         saber "show me all users"         # Run a single query
         saber -d data.csv "show users"    # Run a query with ad-hoc CSV file
         saber -d data.db "show users"     # Run a query with ad-hoc SQLite file
+        saber -d "postgresql://user:pass@host:5432/db" "show users"  # PostgreSQL connection string
+        saber -d "mysql://user:pass@host:3306/db" "show users"       # MySQL connection string
         echo "show me all users" | saber  # Read query from stdin
     """
 
@@ -105,39 +109,13 @@ def query(
                 # If stdin was empty, fall back to interactive mode
                 actual_query = None
 
-        # Get database configuration or handle direct file paths
-        if database:
-            # Check if this is a direct CSV file path
-            if database.endswith(".csv"):
-                csv_path = Path(database).expanduser().resolve()
-                if not csv_path.exists():
-                    raise CLIError(f"CSV file '{database}' not found.")
-                connection_string = f"csv:///{csv_path}"
-                db_name = csv_path.stem
-            # Check if this is a direct SQLite file path
-            elif database.endswith((".db", ".sqlite", ".sqlite3")):
-                sqlite_path = Path(database).expanduser().resolve()
-                if not sqlite_path.exists():
-                    raise CLIError(f"SQLite file '{database}' not found.")
-                connection_string = f"sqlite:///{sqlite_path}"
-                db_name = sqlite_path.stem
-            else:
-                # Look up configured database connection
-                db_config = config_manager.get_database(database)
-                if not db_config:
-                    raise CLIError(
-                        f"Database connection '{database}' not found. Use 'sqlsaber db list' to see available connections."
-                    )
-                connection_string = db_config.to_connection_string()
-                db_name = db_config.name
-        else:
-            db_config = config_manager.get_default_database()
-            if not db_config:
-                raise CLIError(
-                    "No database connections configured. Use 'sqlsaber db add <name>' to add a database connection."
-                )
-            connection_string = db_config.to_connection_string()
-            db_name = db_config.name
+        # Resolve database from CLI input
+        try:
+            resolved = resolve_database(database, config_manager)
+            connection_string = resolved.connection_string
+            db_name = resolved.name
+        except DatabaseResolutionError as e:
+            raise CLIError(str(e))
 
         # Create database connection
         try:

sqlsaber/cli/interactive.py

@@ -136,11 +136,15 @@ class InteractiveSession:
                 if not user_query:
                     continue
 
-                if user_query in ["/exit", "/quit"]:
+                if (
+                    user_query in ["/exit", "/quit"]
+                    or user_query.startswith("/exit")
+                    or user_query.startswith("/quit")
+                ):
                     break
 
                 if user_query == "/clear":
-                    self.agent.clear_history()
+                    await self.agent.clear_history()
                     self.console.print("[green]Conversation history cleared.[/green]\n")
                     continue
 

sqlsaber/conversation/__init__.py

@@ -0,0 +1,12 @@
+"""Conversation history storage for SQLSaber."""
+
+from .manager import ConversationManager
+from .models import Conversation, ConversationMessage
+from .storage import ConversationStorage
+
+__all__ = [
+    "Conversation",
+    "ConversationMessage",
+    "ConversationStorage",
+    "ConversationManager",
+]

sqlsaber/conversation/manager.py

@@ -0,0 +1,224 @@
+"""Manager for conversation storage operations."""
+
+import logging
+import uuid
+from typing import Any
+
+from .models import Conversation, ConversationMessage
+from .storage import ConversationStorage
+
+logger = logging.getLogger(__name__)
+
+
+class ConversationManager:
+    """High-level manager for conversation storage operations."""
+
+    def __init__(self):
+        """Initialize conversation manager."""
+        self._storage = ConversationStorage()
+
+    async def start_conversation(self, database_name: str) -> str:
+        """Start a new conversation.
+
+        Args:
+            database_name: Name of the database for this conversation
+
+        Returns:
+            Conversation ID
+        """
+        try:
+            return await self._storage.create_conversation(database_name)
+        except Exception as e:
+            logger.warning(f"Failed to start conversation: {e}")
+            return str(uuid.uuid4())
+
+    async def add_user_message(
+        self, conversation_id: str, content: str | dict[str, Any], index: int
+    ) -> str:
+        """Add a user message to the conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+            content: Message content
+            index: Sequential index in conversation
+
+        Returns:
+            Message ID
+        """
+        try:
+            return await self._storage.add_message(
+                conversation_id, "user", content, index
+            )
+        except Exception as e:
+            logger.warning(f"Failed to add user message: {e}")
+            return str(uuid.uuid4())
+
+    async def add_assistant_message(
+        self,
+        conversation_id: str,
+        content: list[dict[str, Any]] | dict[str, Any],
+        index: int,
+    ) -> str:
+        """Add an assistant message to the conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+            content: Message content (typically ContentBlock list)
+            index: Sequential index in conversation
+
+        Returns:
+            Message ID
+        """
+        try:
+            return await self._storage.add_message(
+                conversation_id, "assistant", content, index
+            )
+        except Exception as e:
+            logger.warning(f"Failed to add assistant message: {e}")
+            return str(uuid.uuid4())
+
+    async def add_tool_message(
+        self,
+        conversation_id: str,
+        content: list[dict[str, Any]] | dict[str, Any],
+        index: int,
+    ) -> str:
+        """Add a tool/system message to the conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+            content: Message content (typically tool results)
+            index: Sequential index in conversation
+
+        Returns:
+            Message ID
+        """
+        try:
+            return await self._storage.add_message(
+                conversation_id, "tool", content, index
+            )
+        except Exception as e:
+            logger.warning(f"Failed to add tool message: {e}")
+            return str(uuid.uuid4())
+
+    async def end_conversation(self, conversation_id: str) -> bool:
+        """End a conversation.
+
+        Args:
+            conversation_id: ID of the conversation to end
+
+        Returns:
+            True if successfully ended, False otherwise
+        """
+        try:
+            return await self._storage.end_conversation(conversation_id)
+        except Exception as e:
+            logger.warning(f"Failed to end conversation: {e}")
+            return False
+
+    async def get_conversation(self, conversation_id: str) -> Conversation | None:
+        """Get a conversation by ID.
+
+        Args:
+            conversation_id: ID of the conversation
+
+        Returns:
+            Conversation object or None if not found
+        """
+        try:
+            return await self._storage.get_conversation(conversation_id)
+        except Exception as e:
+            logger.warning(f"Failed to get conversation: {e}")
+            return None
+
+    async def get_conversation_messages(
+        self, conversation_id: str
+    ) -> list[ConversationMessage]:
+        """Get all messages for a conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+
+        Returns:
+            List of messages ordered by index
+        """
+        try:
+            return await self._storage.get_conversation_messages(conversation_id)
+        except Exception as e:
+            logger.warning(f"Failed to get conversation messages: {e}")
+            return []
+
+    async def list_conversations(
+        self, database_name: str | None = None, limit: int = 50
+    ) -> list[Conversation]:
+        """List conversations.
+
+        Args:
+            database_name: Optional database name filter
+            limit: Maximum number of conversations to return
+
+        Returns:
+            List of conversations ordered by start time (newest first)
+        """
+        try:
+            return await self._storage.list_conversations(database_name, limit)
+        except Exception as e:
+            logger.warning(f"Failed to list conversations: {e}")
+            return []
+
+    async def delete_conversation(self, conversation_id: str) -> bool:
+        """Delete a conversation.
+
+        Args:
+            conversation_id: ID of the conversation to delete
+
+        Returns:
+            True if successfully deleted, False otherwise
+        """
+        try:
+            return await self._storage.delete_conversation(conversation_id)
+        except Exception as e:
+            logger.warning(f"Failed to delete conversation: {e}")
+            return False
+
+    async def get_database_names(self) -> list[str]:
+        """Get list of database names with conversations.
+
+        Returns:
+            List of unique database names
+        """
+        try:
+            return await self._storage.get_database_names()
+        except Exception as e:
+            logger.warning(f"Failed to get database names: {e}")
+            return []
+
+    async def restore_conversation_to_agent(
+        self, conversation_id: str, agent_history: list[dict[str, Any]]
+    ) -> bool:
+        """Restore a conversation's messages to an agent's in-memory history.
+
+        Args:
+            conversation_id: ID of the conversation to restore
+            agent_history: Agent's conversation_history list to populate
+
+        Returns:
+            True if successfully restored, False otherwise
+        """
+        try:
+            messages = await self.get_conversation_messages(conversation_id)
+
+            # Clear existing history
+            agent_history.clear()
+
+            # Convert messages back to agent format
+            for msg in messages:
+                if msg.role in ("user", "assistant", "tool"):
+                    agent_history.append({"role": msg.role, "content": msg.content})
+
+            logger.debug(f"Restored {len(messages)} messages to agent history")
+            return True
+
+        except Exception as e:
+            logger.warning(f"Failed to restore conversation to agent: {e}")
+            return False

sqlsaber/conversation/models.py

@@ -0,0 +1,120 @@
+"""Data models for conversation storage."""
+
+import json
+import time
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Conversation:
+    """Represents a conversation session."""
+
+    id: str
+    database_name: str
+    started_at: float
+    ended_at: float | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "database_name": self.database_name,
+            "started_at": self.started_at,
+            "ended_at": self.ended_at,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Conversation":
+        """Create from dictionary."""
+        return cls(
+            id=data["id"],
+            database_name=data["database_name"],
+            started_at=data["started_at"],
+            ended_at=data.get("ended_at"),
+        )
+
+    def formatted_start_time(self) -> str:
+        """Get human-readable start timestamp."""
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.started_at))
+
+    def formatted_end_time(self) -> str | None:
+        """Get human-readable end timestamp."""
+        if self.ended_at is None:
+            return None
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.ended_at))
+
+    def duration_seconds(self) -> float | None:
+        """Get conversation duration in seconds."""
+        if self.ended_at is None:
+            return None
+        return self.ended_at - self.started_at
+
+
+@dataclass
+class ConversationMessage:
+    """Represents a single message in a conversation."""
+
+    id: str
+    conversation_id: str
+    role: str
+    content: dict[str, Any] | str
+    index_in_conv: int
+    created_at: float
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "id": self.id,
+            "conversation_id": self.conversation_id,
+            "role": self.role,
+            "content": self.content,
+            "index_in_conv": self.index_in_conv,
+            "created_at": self.created_at,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ConversationMessage":
+        """Create from dictionary."""
+        return cls(
+            id=data["id"],
+            conversation_id=data["conversation_id"],
+            role=data["role"],
+            content=data["content"],
+            index_in_conv=data["index_in_conv"],
+            created_at=data["created_at"],
+        )
+
+    def formatted_timestamp(self) -> str:
+        """Get human-readable timestamp."""
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.created_at))
+
+    def content_json(self) -> str:
+        """Get content as JSON string for storage."""
+        return json.dumps(self.content)
+
+    @classmethod
+    def from_storage_data(
+        cls,
+        id_: str,
+        conversation_id: str,
+        role: str,
+        content_json: str,
+        index_in_conv: int,
+        created_at: float,
+    ) -> "ConversationMessage":
+        """Create from SQLite storage data."""
+        try:
+            content = json.loads(content_json)
+        except json.JSONDecodeError:
+            # Fallback to string content for malformed JSON
+            content = content_json
+
+        return cls(
+            id=id_,
+            conversation_id=conversation_id,
+            role=role,
+            content=content,
+            index_in_conv=index_in_conv,
+            created_at=created_at,
+        )

sqlsaber/conversation/storage.py

@@ -0,0 +1,362 @@
+"""SQLite storage implementation for conversation history."""
+
+import asyncio
+import json
+import logging
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+import aiosqlite
+import platformdirs
+
+from .models import Conversation, ConversationMessage
+
+logger = logging.getLogger(__name__)
+
+# Database schema
+SCHEMA_SQL = """
+-- Conversations table
+CREATE TABLE IF NOT EXISTS conversations (
+    id TEXT PRIMARY KEY,
+    database_name TEXT NOT NULL,
+    started_at REAL NOT NULL,
+    ended_at REAL
+);
+
+-- Messages table
+CREATE TABLE IF NOT EXISTS messages (
+    id TEXT PRIMARY KEY,
+    conversation_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    index_in_conv INTEGER NOT NULL,
+    created_at REAL NOT NULL,
+    FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+);
+
+-- Indices for performance
+CREATE INDEX IF NOT EXISTS idx_messages_conv ON messages(conversation_id, index_in_conv);
+CREATE INDEX IF NOT EXISTS idx_conv_dbname ON conversations(database_name);
+
+-- Store schema version for future migrations
+CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY
+);
+
+INSERT OR IGNORE INTO schema_version (version) VALUES (1);
+"""
+
+
+class ConversationStorage:
+    """Handles SQLite storage and retrieval of conversation history."""
+
+    _DB_VERSION = 1
+
+    def __init__(self):
+        """Initialize conversation storage."""
+        self.db_path = (
+            Path(platformdirs.user_config_dir("sqlsaber")) / "conversations.db"
+        )
+        self._lock = asyncio.Lock()
+        self._initialized: bool = False
+
+    async def _init_db(self) -> None:
+        """Initialize the database with schema if needed."""
+        if self._initialized:
+            return
+
+        try:
+            # Ensure parent directory exists
+            self.db_path.parent.mkdir(parents=True, exist_ok=True)
+
+            async with aiosqlite.connect(self.db_path) as db:
+                await db.executescript(SCHEMA_SQL)
+                await db.commit()
+
+            self._initialized = True
+            logger.debug(f"Initialized conversation database at {self.db_path}")
+
+        except Exception as e:
+            logger.warning(f"Failed to initialize conversation database: {e}")
+            # Don't raise - let the system continue without persistence
+
+    async def create_conversation(self, database_name: str) -> str:
+        """Create a new conversation record.
+
+        Args:
+            database_name: Name of the database for this conversation
+
+        Returns:
+            Conversation ID (UUID)
+        """
+        await self._init_db()
+
+        conversation_id = str(uuid.uuid4())
+        started_at = time.time()
+
+        try:
+            async with self._lock, aiosqlite.connect(self.db_path) as db:
+                await db.execute(
+                    """
+                    INSERT INTO conversations (id, database_name, started_at)
+                    VALUES (?, ?, ?)
+                    """,
+                    (conversation_id, database_name, started_at),
+                )
+                await db.commit()
+
+            logger.debug(
+                f"Created conversation {conversation_id} for db {database_name}"
+            )
+            return conversation_id
+
+        except Exception as e:
+            logger.warning(f"Failed to create conversation: {e}")
+            return conversation_id  # Return ID anyway to allow in-memory operation
+
+    async def add_message(
+        self,
+        conversation_id: str,
+        role: str,
+        content: str | list[dict[str, Any]] | dict[str, Any],
+        index_in_conv: int,
+    ) -> str:
+        """Add a message to a conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+            role: Message role (user, assistant, system, tool)
+            content: Message content (will be JSON-serialized)
+            index_in_conv: Sequential index of message in conversation
+
+        Returns:
+            Message ID (UUID)
+        """
+        await self._init_db()
+
+        message_id = str(uuid.uuid4())
+        created_at = time.time()
+
+        try:
+            async with self._lock, aiosqlite.connect(self.db_path) as db:
+                await db.execute(
+                    """
+                    INSERT INTO messages (id, conversation_id, role, content, index_in_conv, created_at)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        message_id,
+                        conversation_id,
+                        role,
+                        json.dumps(content),
+                        index_in_conv,
+                        created_at,
+                    ),
+                )
+                await db.commit()
+
+            logger.debug(
+                f"Added message {message_id} to conversation {conversation_id}"
+            )
+            return message_id
+
+        except Exception as e:
+            logger.warning(f"Failed to add message: {e}")
+            return message_id  # Return ID anyway
+
+    async def end_conversation(self, conversation_id: str) -> bool:
+        """Mark a conversation as ended.
+
+        Args:
+            conversation_id: ID of the conversation to end
+
+        Returns:
+            True if successfully updated, False otherwise
+        """
+        await self._init_db()
+
+        try:
+            async with self._lock, aiosqlite.connect(self.db_path) as db:
+                await db.execute(
+                    "UPDATE conversations SET ended_at = ? WHERE id = ?",
+                    (time.time(), conversation_id),
+                )
+                await db.commit()
+
+            logger.debug(f"Ended conversation {conversation_id}")
+            return True
+
+        except Exception as e:
+            logger.warning(f"Failed to end conversation: {e}")
+            return False
+
+    async def get_conversation(self, conversation_id: str) -> Conversation | None:
+        """Get a conversation by ID.
+
+        Args:
+            conversation_id: ID of the conversation
+
+        Returns:
+            Conversation object or None if not found
+        """
+        await self._init_db()
+
+        try:
+            async with aiosqlite.connect(self.db_path) as db:
+                async with db.execute(
+                    "SELECT id, database_name, started_at, ended_at FROM conversations WHERE id = ?",
+                    (conversation_id,),
+                ) as cursor:
+                    row = await cursor.fetchone()
+                    if not row:
+                        return None
+
+                    return Conversation(
+                        id=row[0],
+                        database_name=row[1],
+                        started_at=row[2],
+                        ended_at=row[3],
+                    )
+
+        except Exception as e:
+            logger.warning(f"Failed to get conversation {conversation_id}: {e}")
+            return None
+
+    async def get_conversation_messages(
+        self, conversation_id: str
+    ) -> list[ConversationMessage]:
+        """Get all messages for a conversation.
+
+        Args:
+            conversation_id: ID of the conversation
+
+        Returns:
+            List of ConversationMessage objects ordered by index
+        """
+        await self._init_db()
+
+        try:
+            async with aiosqlite.connect(self.db_path) as db:
+                async with db.execute(
+                    """
+                    SELECT id, conversation_id, role, content, index_in_conv, created_at
+                    FROM messages
+                    WHERE conversation_id = ?
+                    ORDER BY index_in_conv
+                    """,
+                    (conversation_id,),
+                ) as cursor:
+                    messages = []
+                    async for row in cursor:
+                        message = ConversationMessage.from_storage_data(
+                            id_=row[0],
+                            conversation_id=row[1],
+                            role=row[2],
+                            content_json=row[3],
+                            index_in_conv=row[4],
+                            created_at=row[5],
+                        )
+                        messages.append(message)
+
+                    return messages
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to get messages for conversation {conversation_id}: {e}"
+            )
+            return []
+
+    async def list_conversations(
+        self, database_name: str | None = None, limit: int = 50
+    ) -> list[Conversation]:
+        """List conversations, optionally filtered by database.
+
+        Args:
+            database_name: Optional database name filter
+            limit: Maximum number of conversations to return
+
+        Returns:
+            List of Conversation objects ordered by start time (newest first)
+        """
+        await self._init_db()
+
+        try:
+            query = """
+                SELECT id, database_name, started_at, ended_at
+                FROM conversations
+            """
+            params = []
+
+            if database_name:
+                query += " WHERE database_name = ?"
+                params.append(database_name)
+
+            query += " ORDER BY started_at DESC LIMIT ?"
+            params.append(limit)
+
+            async with aiosqlite.connect(self.db_path) as db:
+                async with db.execute(query, params) as cursor:
+                    conversations = []
+                    async for row in cursor:
+                        conversation = Conversation(
+                            id=row[0],
+                            database_name=row[1],
+                            started_at=row[2],
+                            ended_at=row[3],
+                        )
+                        conversations.append(conversation)
+
+                    return conversations
+
+        except Exception as e:
+            logger.warning(f"Failed to list conversations: {e}")
+            return []
+
+    async def delete_conversation(self, conversation_id: str) -> bool:
+        """Delete a conversation and all its messages.
+
+        Args:
+            conversation_id: ID of the conversation to delete
+
+        Returns:
+            True if successfully deleted, False otherwise
+        """
+        await self._init_db()
+
+        try:
+            async with self._lock, aiosqlite.connect(self.db_path) as db:
+                # Delete conversation (messages will be deleted by CASCADE)
+                cursor = await db.execute(
+                    "DELETE FROM conversations WHERE id = ?", (conversation_id,)
+                )
+                await db.commit()
+
+                deleted = cursor.rowcount > 0
+                if deleted:
+                    logger.debug(f"Deleted conversation {conversation_id}")
+                return deleted
+
+        except Exception as e:
+            logger.warning(f"Failed to delete conversation {conversation_id}: {e}")
+            return False
+
+    async def get_database_names(self) -> list[str]:
+        """Get list of all database names that have conversations.
+
+        Returns:
+            List of unique database names
+        """
+        await self._init_db()
+
+        try:
+            async with aiosqlite.connect(self.db_path) as db:
+                async with db.execute(
+                    "SELECT DISTINCT database_name FROM conversations ORDER BY database_name"
+                ) as cursor:
+                    return [row[0] async for row in cursor]
+
+        except Exception as e:
+            logger.warning(f"Failed to get database names: {e}")
+            return []

sqlsaber/database/resolver.py

@@ -0,0 +1,96 @@
+"""Database connection resolution from CLI input."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import urlparse
+
+from sqlsaber.config.database import DatabaseConfig, DatabaseConfigManager
+
+
+class DatabaseResolutionError(Exception):
+    """Exception raised when database resolution fails."""
+
+    pass
+
+
+@dataclass
+class ResolvedDatabase:
+    """Result of database resolution containing canonical connection info."""
+
+    name: str  # Human-readable name for display/logging
+    connection_string: str  # Canonical connection string for DatabaseConnection factory
+
+
+SUPPORTED_SCHEMES = {"postgresql", "mysql", "sqlite", "csv"}
+
+
+def _is_connection_string(s: str) -> bool:
+    """Check if string looks like a connection string with supported scheme."""
+    try:
+        scheme = urlparse(s).scheme
+        return scheme in SUPPORTED_SCHEMES
+    except Exception:
+        return False
+
+
+def resolve_database(
+    spec: str | None, config_mgr: DatabaseConfigManager
+) -> ResolvedDatabase:
+    """Turn user CLI input into resolved database connection info.
+
+    Args:
+        spec: User input - None (default), configured name, connection string, or file path
+        config_mgr: Database configuration manager for looking up configured connections
+
+    Returns:
+        ResolvedDatabase with name and canonical connection string
+
+    Raises:
+        DatabaseResolutionError: If the spec cannot be resolved to a valid database connection
+    """
+    if spec is None:
+        db_cfg = config_mgr.get_default_database()
+        if not db_cfg:
+            raise DatabaseResolutionError(
+                "No database connections configured. "
+                "Use 'sqlsaber db add <name>' to add one."
+            )
+        return ResolvedDatabase(
+            name=db_cfg.name,
+            connection_string=db_cfg.to_connection_string(),
+        )
+
+    # 1. Connection string?
+    if _is_connection_string(spec):
+        scheme = urlparse(spec).scheme
+        if scheme in {"postgresql", "mysql"}:
+            db_name = urlparse(spec).path.lstrip("/") or "database"
+        elif scheme in {"sqlite", "csv"}:
+            db_name = Path(urlparse(spec).path).stem
+        else:  # should not happen because of SUPPORTED_SCHEMES
+            db_name = "database"
+        return ResolvedDatabase(name=db_name, connection_string=spec)
+
+    # 2. Raw file path?
+    path = Path(spec).expanduser().resolve()
+    if path.suffix.lower() == ".csv":
+        if not path.exists():
+            raise DatabaseResolutionError(f"CSV file '{spec}' not found.")
+        return ResolvedDatabase(name=path.stem, connection_string=f"csv:///{path}")
+    if path.suffix.lower() in {".db", ".sqlite", ".sqlite3"}:
+        if not path.exists():
+            raise DatabaseResolutionError(f"SQLite file '{spec}' not found.")
+        return ResolvedDatabase(name=path.stem, connection_string=f"sqlite:///{path}")
+
+    # 3. Must be a configured name
+    db_cfg: DatabaseConfig | None = config_mgr.get_database(spec)
+    if not db_cfg:
+        raise DatabaseResolutionError(
+            f"Database connection '{spec}' not found. "
+            "Use 'sqlsaber db list' to see available connections."
+        )
+    return ResolvedDatabase(
+        name=db_cfg.name, connection_string=db_cfg.to_connection_string()
+    )

sqlsaber/database/schema.py

@@ -1,6 +1,5 @@
 """Database schema introspection utilities."""
 
-import time
 from abc import ABC, abstractmethod
 from typing import Any
 
@@ -532,12 +531,10 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
 
 class SchemaManager:
-    """Manages database schema introspection with caching."""
+    """Manages database schema introspection."""
 
-    def __init__(self, db_connection: BaseDatabaseConnection, cache_ttl: int = 900):
+    def __init__(self, db_connection: BaseDatabaseConnection):
         self.db = db_connection
-        self.cache_ttl = cache_ttl  # Default 15 minutes
-        self._schema_cache: dict[str, tuple[float, dict[str, Any]]] = {}
 
         # Select appropriate introspector based on connection type
         if isinstance(db_connection, PostgreSQLConnection):
@@ -551,10 +548,6 @@ class SchemaManager:
                 f"Unsupported database connection type: {type(db_connection)}"
             )
 
-    def clear_schema_cache(self):
-        """Clear the schema cache."""
-        self._schema_cache.clear()
-
     async def get_schema_info(
         self, table_pattern: str | None = None
     ) -> dict[str, SchemaInfo]:
@@ -563,31 +556,6 @@ class SchemaManager:
         Args:
             table_pattern: Optional SQL LIKE pattern to filter tables (e.g., 'public.user%')
         """
-        # Check cache first
-        cache_key = f"schema:{table_pattern or 'all'}"
-        cached_data = self._get_cached_schema(cache_key)
-        if cached_data is not None:
-            return cached_data
-
-        # Fetch from database if not cached
-        schema_info = await self._fetch_schema_from_db(table_pattern)
-
-        # Cache the result
-        self._schema_cache[cache_key] = (time.time(), schema_info)
-        return schema_info
-
-    def _get_cached_schema(self, cache_key: str) -> dict[str, SchemaInfo] | None:
-        """Get schema from cache if available and not expired."""
-        if cache_key in self._schema_cache:
-            cached_time, cached_data = self._schema_cache[cache_key]
-            if time.time() - cached_time < self.cache_ttl:
-                return cached_data
-        return None
-
-    async def _fetch_schema_from_db(
-        self, table_pattern: str | None
-    ) -> dict[str, SchemaInfo]:
-        """Fetch schema information from database."""
         # Get all schema components
         tables = await self.introspector.get_tables_info(self.db, table_pattern)
         columns = await self.introspector.get_columns_info(self.db, tables)
@@ -672,13 +640,6 @@ class SchemaManager:
 
     async def list_tables(self) -> dict[str, Any]:
         """Get a list of all tables with basic information."""
-        # Check cache first
-        cache_key = "list_tables"
-        cached_data = self._get_cached_tables(cache_key)
-        if cached_data is not None:
-            return cached_data
-
-        # Fetch from database if not cached
         tables = await self.introspector.list_tables_info(self.db)
 
         # Format the result
@@ -694,14 +655,4 @@ class SchemaManager:
                 }
             )
 
-        # Cache the result
-        self._schema_cache[cache_key] = (time.time(), result)
         return result
-
-    def _get_cached_tables(self, cache_key: str) -> dict[str, Any] | None:
-        """Get table list from cache if available and not expired."""
-        if cache_key in self._schema_cache:
-            cached_time, cached_data = self._schema_cache[cache_key]
-            if time.time() - cached_time < self.cache_ttl:
-                return cached_data
-        return None

{sqlsaber-0.12.0.dist-info → sqlsaber-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.12.0
+Version: 0.14.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlsaber-0.12.0.dist-info → sqlsaber-0.14.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
 sqlsaber/__init__.py,sha256=HjS8ULtP4MGpnTL7njVY45NKV9Fi4e_yeYuY-hyXWQc,73
 sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
 sqlsaber/agents/__init__.py,sha256=LWeSeEUE4BhkyAYFF3TE-fx8TtLud3oyEtyB8ojFJgo,167
-sqlsaber/agents/anthropic.py,sha256=CBHneR5NJhu155d0-D1mSGOcTH7kmbXZSLv2mVQotSM,22128
-sqlsaber/agents/base.py,sha256=Cl5ZV4dfgjslOAq8jbrnt5kX-NM_8QmjacWzb0hvbzs,10527
+sqlsaber/agents/anthropic.py,sha256=xH4xY1lq5idDgY8Vklgu5hGLoKLHWQMMfPgjvQjfG7I,23615
+sqlsaber/agents/base.py,sha256=9A-iceb93eHrQHTdLoeSicP3ZqDHOFTx3Fe5OvHvUkg,14093
 sqlsaber/agents/mcp.py,sha256=FKtXgDrPZ2-xqUYCw2baI5JzrWekXaC5fjkYW1_Mg50,827
 sqlsaber/agents/streaming.py,sha256=LaSeMTlxuJFRArJVqDly5-_KgcePiCCKPKfMxfB4oGs,521
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
 sqlsaber/cli/auth.py,sha256=1yvawtS5NGj9dWMRZ8I5T6sqBiRqZpPsjEPrJSQBJAs,4979
-sqlsaber/cli/commands.py,sha256=rhbfpXNrWLQbiEEqn4GDwE175vhOWrfPiTRP32Ui7NM,7156
+sqlsaber/cli/commands.py,sha256=VX7pqQnf-85A9zkjXqzytVNeCG8KO0mB2TyIEzB4sh8,6241
 sqlsaber/cli/completers.py,sha256=HsUPjaZweLSeYCWkAcgMl8FylQ1xjWBWYTEL_9F6xfU,6430
 sqlsaber/cli/database.py,sha256=tJ8rqGrafZpg3VgDmSiq7eZoPscoGAW3XLTYGoQw8LE,12910
 sqlsaber/cli/display.py,sha256=HtXwPe3VPUh2EJpyvpJVWyisCanu9O7w-rkqq7Y4UaY,9791
-sqlsaber/cli/interactive.py,sha256=NjrhzXt6YK4WL17DMkJTY5dA1v9QMxLdkI1XgPKK8YA,8017
+sqlsaber/cli/interactive.py,sha256=7RjUMMPJ49RUuUGn-gP6vgiW6Ccvin9mzmRL-9p6eto,8171
 sqlsaber/cli/memory.py,sha256=OufHFJFwV0_GGn7LvKRTJikkWhV1IwNIUDOxFPHXOaQ,7794
 sqlsaber/cli/models.py,sha256=HByezaeKqj65GzB_FmWuugjkgTq2Pvab_mzNZnHxya0,7690
 sqlsaber/cli/streaming.py,sha256=WfhFd5ntq2HStpJZwWJ0C5uyXKc3aU14eo8HdjzW1o0,3767
@@ -28,9 +28,14 @@ sqlsaber/config/database.py,sha256=c6q3l4EvoBch1ckYHA70hf6L7fSOY-sItnLCpvJiPrA,1
 sqlsaber/config/oauth_flow.py,sha256=A3bSXaBLzuAfXV2ZPA94m9NV33c2MyL6M4ii9oEkswQ,10291
 sqlsaber/config/oauth_tokens.py,sha256=C9z35hyx-PvSAYdC1LNf3rg9_wsEIY56hkEczelbad0,6015
 sqlsaber/config/settings.py,sha256=gKhGlErzsBk39RoRSy1b8pb-bN2K7HIaPaBgbJDhY4M,4753
+sqlsaber/conversation/__init__.py,sha256=xa-1gX6NsZpVGg_LDrsZAtDtsDo5FZc1SO8gwtm_IPk,302
+sqlsaber/conversation/manager.py,sha256=LDfmKGIMvTzsL7S0aXGWw6Ve54CHIeTGLU4qwes2NgU,7046
+sqlsaber/conversation/models.py,sha256=fq4wpIB2yxLCQtsXhdpDji4FpscG2ayrOBACrNvgF14,3510
+sqlsaber/conversation/storage.py,sha256=phpGEnZjXVFTmV5PalCKZpiO9VFHubMMfWA9OJCDbwc,11626
 sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
 sqlsaber/database/connection.py,sha256=sZVGNMzMwiM11GrsLLPwR8A5ugzJ5O0TCdkrt0KVRuI,15123
-sqlsaber/database/schema.py,sha256=anlxjr_4-gEWlEjQgZ5h4KGMfbS0-aQH1VwhXIw41Q4,27951
+sqlsaber/database/resolver.py,sha256=RPXF5EoKzvQDDLmPGNHYd2uG_oNICH8qvUjBp6iXmNY,3348
+sqlsaber/database/schema.py,sha256=OC93dnZkijCoVNqb6itSpQ2XsiZ85PjVUW-VZDwrPrk,25989
 sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
 sqlsaber/mcp/mcp.py,sha256=YH4crygqb5_Y94nsns6d-26FZCTlDPOh3tf-ghihzDM,4440
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
@@ -39,8 +44,8 @@ sqlsaber/memory/storage.py,sha256=ne8szLlGj5NELheqLnI7zu21V8YS4rtpYGGC7tOmi-s,57
 sqlsaber/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
 sqlsaber/models/events.py,sha256=89SXKb5GGpH01yTr2kPEBhzp9xv35RFIYuFdAZSIPoE,721
 sqlsaber/models/types.py,sha256=w-zk81V2dtveuteej36_o1fDK3So428j3P2rAejU62U,862
-sqlsaber-0.12.0.dist-info/METADATA,sha256=k_OjB22bXlyVvH_nPTEIBjLwwzmdsAntYs6_rl7LSzg,6877
-sqlsaber-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.12.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
-sqlsaber-0.12.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.12.0.dist-info/RECORD,,
+sqlsaber-0.14.0.dist-info/METADATA,sha256=xAj3wcH-3OJWud9grNykoiHhuVp2LIdMV5bbxNUQOEk,6877
+sqlsaber-0.14.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.14.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
+sqlsaber-0.14.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.14.0.dist-info/RECORD,,