sqlsaber 0.13.0__tar.gz → 0.14.0__tar.gz

{sqlsaber-0.13.0 → sqlsaber-0.14.0}/.github/workflows/claude-code-review.yml

@@ -17,14 +17,14 @@ jobs:
     #   github.event.pull_request.user.login == 'external-contributor' ||
     #   github.event.pull_request.user.login == 'new-developer' ||
     #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
-    
+
     runs-on: ubuntu-latest
     permissions:
       contents: read
       pull-requests: read
       issues: read
       id-token: write
-    
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -39,7 +39,7 @@ jobs:
 
           # Optional: Specify model (defaults to Claude Sonnet 4, uncomment for Claude Opus 4)
           # model: "claude-opus-4-20250514"
-          
+
           # Direct prompt for automated review (no @claude mention needed)
           direct_prompt: |
             Please review this pull request and provide feedback on:
@@ -48,12 +48,12 @@ jobs:
             - Performance considerations
             - Security concerns
             - Test coverage
-            
+
             Be constructive and helpful in your feedback.
 
           # Optional: Use sticky comments to make Claude reuse the same comment on subsequent pushes to the same PR
           # use_sticky_comment: true
-          
+
           # Optional: Customize review based on file types
           # direct_prompt: |
           #   Review this PR focusing on:
@@ -61,18 +61,17 @@ jobs:
           #   - For API endpoints: Security, input validation, and error handling
           #   - For React components: Performance, accessibility, and best practices
           #   - For tests: Coverage, edge cases, and test quality
-          
+
           # Optional: Different prompts for different authors
           # direct_prompt: |
-          #   ${{ github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR' && 
+          #   ${{ github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR' &&
           #   'Welcome! Please review this PR from a first-time contributor. Be encouraging and provide detailed explanations for any suggestions.' ||
           #   'Please provide a thorough code review focusing on our coding standards and best practices.' }}
-          
+
           # Optional: Add specific tools for running tests or linting
           # allowed_tools: "Bash(npm run test),Bash(npm run lint),Bash(npm run typecheck)"
-          
-          # Optional: Skip review for certain conditions
-          # if: |
-          #   !contains(github.event.pull_request.title, '[skip-review]') &&
-          #   !contains(github.event.pull_request.title, '[WIP]')
 
+        # Optional: Skip review for certain conditions
+        if: |
+          !contains(github.event.pull_request.title, '[skip-review]') &&
+          !contains(github.event.pull_request.title, '[WIP]')

sqlsaber-0.14.0/.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+# Cancel active CI runs for a PR before starting another run
+concurrency:
+  group: ${{ github.workflow}}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: uv sync --locked --all-extras --dev
+
+      - name: Run tests
+        run: uv run python -m pytest

{sqlsaber-0.13.0 → sqlsaber-0.14.0}/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to SQLSaber will be documented in this file.
 
 ## [Unreleased]
 
+## [0.14.0] - 2025-08-01
+
+### Added
+
+- Local conversation storage between user and agent
+  - Store conversation history persistently
+  - Track messages with proper attribution
+- Added automated test execution in CI
+  - New GitHub Actions workflow for running tests
+  - Updated code review workflow
+
+### Fixed
+
+- Fixed CLI commands test suite (#11)
+
+### Changed
+
+- Removed schema caching from SchemaManager
+  - Simplified schema introspection by removing cache logic
+  - Direct database queries for schema information
+
 ## [0.13.0] - 2025-07-26
 
 ### Added

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sqlsaber"
-version = "0.13.0"
+version = "0.14.0"
 description = "SQLSaber - Agentic SQL assistant like Claude Code"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlsaber-0.13.0 → sqlsaber-0.14.0}/src/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-0.13.0 → sqlsaber-0.14.0}/src/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-0.13.0 → sqlsaber-0.14.0}/src/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-0.14.0/src/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-0.14.0/src/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