sqlsaber 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

sqlsaber/cli/completers.py

@@ -0,0 +1,172 @@
+"""Command line completers for the CLI interface."""
+
+from typing import List, Tuple
+
+from prompt_toolkit.completion import Completer, Completion
+
+
+class SlashCommandCompleter(Completer):
+    """Custom completer for slash commands."""
+
+    def get_completions(self, document, complete_event):
+        """Get completions for slash commands."""
+        # Only provide completions if the line starts with "/"
+        text = document.text
+        if text.startswith("/"):
+            # Get the partial command after the slash
+            partial_cmd = text[1:]
+
+            # Define available commands with descriptions
+            commands = [
+                ("clear", "Clear conversation history"),
+                ("exit", "Exit the interactive session"),
+                ("quit", "Exit the interactive session"),
+            ]
+
+            # Yield completions that match the partial command
+            for cmd, description in commands:
+                if cmd.startswith(partial_cmd):
+                    yield Completion(
+                        cmd,
+                        start_position=-len(partial_cmd),
+                        display_meta=description,
+                    )
+
+
+class TableNameCompleter(Completer):
+    """Custom completer for table names."""
+
+    def __init__(self):
+        self._table_cache: List[Tuple[str, str]] = []
+
+    def update_cache(self, tables_data: List[Tuple[str, str]]):
+        """Update the cache with fresh table data."""
+        self._table_cache = tables_data
+
+    def _get_table_names(self) -> List[Tuple[str, str]]:
+        """Get table names from cache."""
+        return self._table_cache
+
+    def get_completions(self, document, complete_event):
+        """Get completions for table names with fuzzy matching."""
+        text = document.text
+        cursor_position = document.cursor_position
+
+        # Find the last "@" before the cursor position
+        at_pos = text.rfind("@", 0, cursor_position)
+
+        if at_pos >= 0:
+            # Extract text after the "@" up to the cursor
+            partial_table = text[at_pos + 1 : cursor_position].lower()
+
+            # Check if this looks like a valid table reference context
+            # (not inside quotes, and followed by word characters or end of input)
+            if self._is_valid_table_context(text, at_pos, cursor_position):
+                # Get table names
+                tables = self._get_table_names()
+
+                # Collect matches with scores for ranking
+                matches = []
+
+                for table_name, description in tables:
+                    table_lower = table_name.lower()
+                    score = self._calculate_match_score(
+                        partial_table, table_name, table_lower
+                    )
+
+                    if score > 0:
+                        matches.append((score, table_name, description))
+
+                # Sort by score (higher is better) and yield completions
+                matches.sort(key=lambda x: x[0], reverse=True)
+
+                for score, table_name, description in matches:
+                    yield Completion(
+                        table_name,
+                        start_position=at_pos
+                        + 1
+                        - cursor_position,  # Start from after the @
+                        display_meta=description if description else None,
+                    )
+
+    def _is_valid_table_context(self, text: str, at_pos: int, cursor_pos: int) -> bool:
+        """Check if the @ is in a valid context for table completion."""
+        # Simple heuristic: avoid completion inside quoted strings
+
+        # Count quotes before the @ position
+        single_quotes = text[:at_pos].count("'") - text[:at_pos].count("\\'")
+        double_quotes = text[:at_pos].count('"') - text[:at_pos].count('\\"')
+
+        # If we're inside quotes, don't complete
+        if single_quotes % 2 == 1 or double_quotes % 2 == 1:
+            return False
+
+        # Check if the character after the cursor (if any) is part of a word
+        # This helps avoid breaking existing words
+        if cursor_pos < len(text):
+            next_char = text[cursor_pos]
+            if next_char.isalnum() or next_char == "_":
+                # We're in the middle of a word, check if it looks like a table name
+                partial = (
+                    text[at_pos + 1 :].split()[0] if text[at_pos + 1 :].split() else ""
+                )
+                if not any(c in partial for c in [".", "_"]):
+                    return False
+
+        return True
+
+    def _calculate_match_score(
+        self, partial: str, table_name: str, table_lower: str
+    ) -> int:
+        """Calculate match score for fuzzy matching (higher is better)."""
+        if not partial:
+            return 1  # Empty search matches everything with low score
+
+        # Score 100: Exact full name prefix match
+        if table_lower.startswith(partial):
+            return 100
+
+        # Score 90: Table name (after schema) prefix match
+        if "." in table_name:
+            table_part = table_name.split(".")[-1].lower()
+            if table_part.startswith(partial):
+                return 90
+
+        # Score 80: Exact table name match (for short names)
+        if "." in table_name:
+            table_part = table_name.split(".")[-1].lower()
+            if table_part == partial:
+                return 80
+
+        # Score 70: Word boundary matches (e.g., "user" matches "user_accounts")
+        if "." in table_name:
+            table_part = table_name.split(".")[-1].lower()
+            if table_part.startswith(partial + "_") or table_part.startswith(
+                partial + "-"
+            ):
+                return 70
+
+        # Score 50: Substring match in table name part
+        if "." in table_name:
+            table_part = table_name.split(".")[-1].lower()
+            if partial in table_part:
+                return 50
+
+        # Score 30: Substring match in full name
+        if partial in table_lower:
+            return 30
+
+        # Score 0: No match
+        return 0
+
+
+class CompositeCompleter(Completer):
+    """Combines multiple completers."""
+
+    def __init__(self, *completers: Completer):
+        self.completers = completers
+
+    def get_completions(self, document, complete_event):
+        """Get completions from all registered completers."""
+        for completer in self.completers:
+            yield from completer.get_completions(document, complete_event)

sqlsaber/cli/display.py

@@ -4,6 +4,7 @@ import json
 from typing import Optional
 
 from rich.console import Console
+from rich.markdown import Markdown
 from rich.syntax import Syntax
 from rich.table import Table
 
@@ -243,3 +244,24 @@ class DisplayManager:
             self.show_error("Failed to parse plot result")
         except Exception as e:
             self.show_error(f"Error displaying plot: {str(e)}")
+
+    def show_markdown_response(self, content: list):
+        """Display the assistant's response as rich markdown."""
+        if not content:
+            return
+
+        # Extract text from content blocks
+        text_parts = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                text = block.get("text", "")
+                if text:
+                    text_parts.append(text)
+
+        # Join all text parts and display as markdown
+        full_text = "".join(text_parts).strip()
+        if full_text:
+            self.console.print()  # Add spacing before markdown
+            markdown = Markdown(full_text)
+            self.console.print(markdown)
+            self.console.print()  # Add spacing after markdown

sqlsaber/cli/interactive.py

@@ -4,43 +4,19 @@ import asyncio
 from typing import Optional
 
 import questionary
-from prompt_toolkit.completion import Completer, Completion
 from rich.console import Console
 from rich.panel import Panel
 
 from sqlsaber.agents.base import BaseSQLAgent
+from sqlsaber.cli.completers import (
+    CompositeCompleter,
+    SlashCommandCompleter,
+    TableNameCompleter,
+)
 from sqlsaber.cli.display import DisplayManager
 from sqlsaber.cli.streaming import StreamingQueryHandler
 
 
-class SlashCommandCompleter(Completer):
-    """Custom completer for slash commands."""
-
-    def get_completions(self, document, complete_event):
-        """Get completions for slash commands."""
-        # Only provide completions if the line starts with "/"
-        text = document.text
-        if text.startswith("/"):
-            # Get the partial command after the slash
-            partial_cmd = text[1:]
-
-            # Define available commands with descriptions
-            commands = [
-                ("clear", "Clear conversation history"),
-                ("exit", "Exit the interactive session"),
-                ("quit", "Exit the interactive session"),
-            ]
-
-            # Yield completions that match the partial command
-            for cmd, description in commands:
-                if cmd.startswith(partial_cmd):
-                    yield Completion(
-                        cmd,
-                        start_position=-len(partial_cmd),
-                        display_meta=description,
-                    )
-
-
 class InteractiveSession:
     """Manages interactive CLI sessions."""
 
@@ -51,6 +27,7 @@ class InteractiveSession:
         self.streaming_handler = StreamingQueryHandler(console)
         self.current_task: Optional[asyncio.Task] = None
         self.cancellation_token: Optional[asyncio.Event] = None
+        self.table_completer = TableNameCompleter()
 
     def show_welcome_message(self):
         """Display welcome message for interactive mode."""
@@ -63,7 +40,8 @@ class InteractiveSession:
                 "[bold green]SQLSaber - Use the agent Luke![/bold green]\n\n"
                 "[bold]Your agentic SQL assistant.[/bold]\n\n\n"
                 "[dim]Use '/clear' to reset conversation, '/exit' or '/quit' to leave.[/dim]\n\n"
-                "[dim]Start a message with '#' to add something to agent's memory for this database.[/dim]",
+                "[dim]Start a message with '#' to add something to agent's memory for this database.[/dim]\n\n"
+                "[dim]Type '@' to get table name completions.[/dim]",
                 border_style="green",
             )
         )
@@ -75,6 +53,39 @@ class InteractiveSession:
             "[dim]Press Ctrl+C during query execution to interrupt and return to prompt.[/dim]\n"
         )
 
+    async def _update_table_cache(self):
+        """Update the table completer cache with fresh data."""
+        try:
+            # Use the schema manager directly which has built-in caching
+            tables_data = await self.agent.schema_manager.list_tables()
+
+            # Parse the table information
+            table_list = []
+            if isinstance(tables_data, dict) and "tables" in tables_data:
+                for table in tables_data["tables"]:
+                    if isinstance(table, dict):
+                        name = table.get("name", "")
+                        schema = table.get("schema", "")
+                        full_name = table.get("full_name", "")
+
+                        # Use full_name if available, otherwise construct it
+                        if full_name:
+                            table_name = full_name
+                        elif schema and schema != "main":
+                            table_name = f"{schema}.{name}"
+                        else:
+                            table_name = name
+
+                        # No description needed - cleaner completions
+                        table_list.append((table_name, ""))
+
+            # Update the completer cache
+            self.table_completer.update_cache(table_list)
+
+        except Exception:
+            # If there's an error, just use empty cache
+            self.table_completer.update_cache([])
+
     async def _execute_query_with_cancellation(self, user_query: str):
         """Execute a query with cancellation support."""
         # Create cancellation token
@@ -101,6 +112,9 @@ class InteractiveSession:
         """Run the interactive session loop."""
         self.show_welcome_message()
 
+        # Initialize table cache
+        await self._update_table_cache()
+
         while True:
             try:
                 user_query = await questionary.text(
@@ -108,7 +122,9 @@ class InteractiveSession:
                     qmark="",
                     multiline=True,
                     instruction="",
-                    completer=SlashCommandCompleter(),
+                    completer=CompositeCompleter(
+                        SlashCommandCompleter(), self.table_completer
+                    ),
                 ).ask_async()
 
                 if not user_query:

sqlsaber/cli/streaming.py

@@ -110,6 +110,14 @@ class StreamingQueryHandler:
             if explanation_started:
                 self.display.show_newline()  # Empty line for better readability
 
+            # Display the last assistant response as markdown
+            if hasattr(agent, "conversation_history") and agent.conversation_history:
+                last_message = agent.conversation_history[-1]
+                if last_message.get("role") == "assistant" and last_message.get(
+                    "content"
+                ):
+                    self.display.show_markdown_response(last_message["content"])
+
     def _stop_status(self, status):
         """Safely stop a status spinner."""
         try:

sqlsaber/database/schema.py

@@ -683,6 +683,13 @@ class SchemaManager:
 
     async def list_tables(self) -> Dict[str, Any]:
         """Get a list of all tables with basic information like row counts."""
+        # 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
@@ -699,4 +706,14 @@ class SchemaManager:
                 }
             )
 
+        # Cache the result
+        self._schema_cache[cache_key] = (time.time(), result)
         return result
+
+    def _get_cached_tables(self, cache_key: str) -> Optional[Dict[str, Any]]:
+        """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.6.0.dist-info → sqlsaber-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.6.0
+Version: 0.7.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -212,23 +212,24 @@ The MCP server uses your existing SQLSaber database configurations, so make sure
 
 ## How It Works
 
-SQLSaber uses an intelligent three-step process optimized for minimal token usage:
+SQLSaber uses a multi-step process to gather the right context, provide it to the model, and execute SQL queries to get the right answers:
+
+![](./sqlsaber.svg)
 
 ### 🔍 Discovery Phase
 
 1. **List Tables Tool**: Quickly discovers available tables with row counts
-2. **Pattern Matching**: Identifies relevant tables based on your query using SQL LIKE patterns
+2. **Pattern Matching**: Identifies relevant tables based on your query
 
 ### 📋 Schema Analysis
 
-3. **Smart Introspection**: Analyzes only the specific table structures needed for your query
-4. **Selective Loading**: Fetches schema information only for relevant tables
+3. **Smart Schema Introspection**: Analyzes only the specific table structures needed for your query
 
 ### ⚡ Execution Phase
 
-5. **SQL Generation**: Creates optimized SQL queries based on natural language input
-6. **Safe Execution**: Runs queries with built-in protections against destructive operations
-7. **Result Formatting**: Presents results with syntax highlighting and explanations
+4. **SQL Generation**: Creates optimized SQL queries based on natural language input
+5. **Safe Execution**: Runs read-only queries with built-in protections against destructive operations
+6. **Result Formatting**: Presents results with explanations in tables and optionally, visualizes using plots
 
 ## Contributing
 

{sqlsaber-0.6.0.dist-info → sqlsaber-0.7.0.dist-info}/RECORD

@@ -7,19 +7,20 @@ sqlsaber/agents/mcp.py,sha256=FKtXgDrPZ2-xqUYCw2baI5JzrWekXaC5fjkYW1_Mg50,827
 sqlsaber/agents/streaming.py,sha256=_EO390-FHUrL1fRCNfibtE9QuJz3LGQygbwG3CB2ViY,533
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
 sqlsaber/cli/commands.py,sha256=Dw24W0jij-8t1lpk99C4PBTgzFSag6vU-FZcjAYGG54,5074
+sqlsaber/cli/completers.py,sha256=JWOCKAm0Prpy_O2QJsf_VbPWfy2lQQh6KutyG8FU4us,6462
 sqlsaber/cli/database.py,sha256=DUfyvNBDp47oFM_VAC_hXHQy_qyE7JbXtowflJpwwH8,12643
-sqlsaber/cli/display.py,sha256=lZW7BI2LusU5lJhov7u9kKWwfsqcXGSfjrw-kNO3FQA,9200
-sqlsaber/cli/interactive.py,sha256=RNEWyCM1gLLUsXaXaCFzXu0PFDVuAK8NBOOYYFTHTUE,6716
+sqlsaber/cli/display.py,sha256=NIBWHUrX_8ZhDu6iW9v4fzx0zncnXa5WdQ9wfTrjKIM,10017
+sqlsaber/cli/interactive.py,sha256=FvgtT45U-yblhbRImKqJ4jgBRNs0u7NhE2PcgoVUaVA,7429
 sqlsaber/cli/memory.py,sha256=LW4ZF2V6Gw6hviUFGZ4ym9ostFCwucgBTIMZ3EANO-I,7671
 sqlsaber/cli/models.py,sha256=3IcXeeU15IQvemSv-V-RQzVytJ3wuQ4YmWk89nTDcSE,7813
-sqlsaber/cli/streaming.py,sha256=2vLCYqqziQTO52erfgvnEk_hM3BoDM1TMBAXgT7KKfo,4548
+sqlsaber/cli/streaming.py,sha256=DfwygmjEzAh9hZGKjrW9kS1A7MG5W9Ky_kCTzxziODQ,4970
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
 sqlsaber/config/api_keys.py,sha256=kLdoExF_My9ojmdhO5Ca7-ZeowsO0v1GVa_QT5jjUPo,3658
 sqlsaber/config/database.py,sha256=vKFOxPjVakjQhj1uoLcfzhS9ZFr6Z2F5b4MmYALQZoA,11421
 sqlsaber/config/settings.py,sha256=zjQ7nS3ybcCb88Ea0tmwJox5-q0ettChZw89ZqRVpX8,3975
 sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
 sqlsaber/database/connection.py,sha256=s8GSFZebB8be8sVUr-N0x88-20YfkfljJFRyfoB1gH0,15154
-sqlsaber/database/schema.py,sha256=9QoH-gADzWlepq-tGz3nPU3miSUU0koWmpDaoWvz8Q0,27951
+sqlsaber/database/schema.py,sha256=3CfkyhxgD6SmiUoz7MQPlQLrrA007HOQLnGCvvsdJx0,28647
 sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
 sqlsaber/mcp/mcp.py,sha256=ACm1P1TnicjOptQgeLNhXg5xgZf4MYq2kqdfVdj6wh0,4477
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
@@ -28,8 +29,8 @@ sqlsaber/memory/storage.py,sha256=DvZBsSPaAfk_DqrNEn86uMD-TQsWUI6rQLfNw6PSCB8,57
 sqlsaber/models/__init__.py,sha256=RJ7p3WtuSwwpFQ1Iw4_DHV2zzCtHqIzsjJzxv8kUjUE,287
 sqlsaber/models/events.py,sha256=q2FackB60J9-7vegYIjzElLwKebIh7nxnV5AFoZc67c,752
 sqlsaber/models/types.py,sha256=3U_30n91EB3IglBTHipwiW4MqmmaA2qfshfraMZyPps,896
-sqlsaber-0.6.0.dist-info/METADATA,sha256=Mvou6xXxA8T2Cfwq4y1bd0DYW46zBs4Qw7oXWNfihfE,5969
-sqlsaber-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.6.0.dist-info/entry_points.txt,sha256=jmFo96Ylm0zIKXJBwhv_P5wQ7SXP9qdaBcnTp8iCEe8,195
-sqlsaber-0.6.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.6.0.dist-info/RECORD,,
+sqlsaber-0.7.0.dist-info/METADATA,sha256=tUV3WHkVZEXissVrKAaOooaZyn7e_NmMV_e-nNaoLVE,5986
+sqlsaber-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.7.0.dist-info/entry_points.txt,sha256=jmFo96Ylm0zIKXJBwhv_P5wQ7SXP9qdaBcnTp8iCEe8,195
+sqlsaber-0.7.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.7.0.dist-info/RECORD,,