sqlsaber 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

sqlsaber/database/sqlite.py

@@ -0,0 +1,258 @@
+"""SQLite database connection and schema introspection."""
+
+import asyncio
+from typing import Any
+
+import aiosqlite
+
+from .base import (
+    DEFAULT_QUERY_TIMEOUT,
+    BaseDatabaseConnection,
+    BaseSchemaIntrospector,
+    QueryTimeoutError,
+)
+
+
+class SQLiteConnection(BaseDatabaseConnection):
+    """SQLite database connection using aiosqlite."""
+
+    def __init__(self, connection_string: str):
+        super().__init__(connection_string)
+        # Extract database path from sqlite:///path format
+        self.database_path = connection_string.replace("sqlite:///", "")
+
+    async def get_pool(self):
+        """SQLite doesn't use connection pooling, return database path."""
+        return self.database_path
+
+    async def close(self):
+        """SQLite connections are created per query, no persistent pool to close."""
+        pass
+
+    async def execute_query(
+        self, query: str, *args, timeout: float | None = None
+    ) -> list[dict[str, Any]]:
+        """Execute a query and return results as list of dicts.
+
+        All queries run in a transaction that is rolled back at the end,
+        ensuring no changes are persisted to the database.
+        """
+        effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
+
+        async with aiosqlite.connect(self.database_path) as conn:
+            # Enable row factory for dict-like access
+            conn.row_factory = aiosqlite.Row
+
+            # Start transaction
+            await conn.execute("BEGIN")
+            try:
+                # Execute query with client-side timeout (SQLite has no server-side timeout)
+                if effective_timeout:
+                    cursor = await asyncio.wait_for(
+                        conn.execute(query, args if args else ()),
+                        timeout=effective_timeout,
+                    )
+                    rows = await asyncio.wait_for(
+                        cursor.fetchall(), timeout=effective_timeout
+                    )
+                else:
+                    cursor = await conn.execute(query, args if args else ())
+                    rows = await cursor.fetchall()
+
+                return [dict(row) for row in rows]
+            except asyncio.TimeoutError as exc:
+                raise QueryTimeoutError(effective_timeout or 0) from exc
+            finally:
+                # Always rollback to ensure no changes are committed
+                await conn.rollback()
+
+
+class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
+    """SQLite-specific schema introspection."""
+
+    async def _execute_query(self, connection, query: str, params=()) -> list:
+        """Helper method to execute queries on both SQLite and CSV connections."""
+        # Handle both SQLite and CSV connections
+        if hasattr(connection, "database_path"):
+            # Regular SQLite connection
+            async with aiosqlite.connect(connection.database_path) as conn:
+                conn.row_factory = aiosqlite.Row
+                cursor = await conn.execute(query, params)
+                return await cursor.fetchall()
+        else:
+            # CSV connection - use the existing connection
+            conn = await connection.get_pool()
+            cursor = await conn.execute(query, params)
+            return await cursor.fetchall()
+
+    async def get_tables_info(
+        self, connection, table_pattern: str | None = None
+    ) -> dict[str, Any]:
+        """Get tables information for SQLite."""
+        where_conditions = ["type IN ('table', 'view')", "name NOT LIKE 'sqlite_%'"]
+        params = ()
+
+        if table_pattern:
+            where_conditions.append("name LIKE ?")
+            params = (table_pattern,)
+
+        query = f"""
+            SELECT
+                'main' as table_schema,
+                name as table_name,
+                type as table_type
+            FROM sqlite_master
+            WHERE {" AND ".join(where_conditions)}
+            ORDER BY name;
+        """
+
+        return await self._execute_query(connection, query, params)
+
+    async def get_columns_info(self, connection, tables: list) -> list:
+        """Get columns information for SQLite."""
+        if not tables:
+            return []
+
+        columns = []
+        for table in tables:
+            table_name = table["table_name"]
+
+            # Get table info using PRAGMA
+            pragma_query = f"PRAGMA table_info({table_name})"
+            table_columns = await self._execute_query(connection, pragma_query)
+
+            for col in table_columns:
+                columns.append(
+                    {
+                        "table_schema": "main",
+                        "table_name": table_name,
+                        "column_name": col["name"],
+                        "data_type": col["type"],
+                        "is_nullable": "YES" if not col["notnull"] else "NO",
+                        "column_default": col["dflt_value"],
+                        "character_maximum_length": None,
+                        "numeric_precision": None,
+                        "numeric_scale": None,
+                    }
+                )
+
+        return columns
+
+    async def get_foreign_keys_info(self, connection, tables: list) -> list:
+        """Get foreign keys information for SQLite."""
+        if not tables:
+            return []
+
+        foreign_keys = []
+        for table in tables:
+            table_name = table["table_name"]
+
+            # Get foreign key info using PRAGMA
+            pragma_query = f"PRAGMA foreign_key_list({table_name})"
+            table_fks = await self._execute_query(connection, pragma_query)
+
+            for fk in table_fks:
+                foreign_keys.append(
+                    {
+                        "table_schema": "main",
+                        "table_name": table_name,
+                        "column_name": fk["from"],
+                        "foreign_table_schema": "main",
+                        "foreign_table_name": fk["table"],
+                        "foreign_column_name": fk["to"],
+                    }
+                )
+
+        return foreign_keys
+
+    async def get_primary_keys_info(self, connection, tables: list) -> list:
+        """Get primary keys information for SQLite."""
+        if not tables:
+            return []
+
+        primary_keys = []
+        for table in tables:
+            table_name = table["table_name"]
+
+            # Get table info using PRAGMA to find primary keys
+            pragma_query = f"PRAGMA table_info({table_name})"
+            table_columns = await self._execute_query(connection, pragma_query)
+
+            for col in table_columns:
+                if col["pk"]:  # Primary key indicator
+                    primary_keys.append(
+                        {
+                            "table_schema": "main",
+                            "table_name": table_name,
+                            "column_name": col["name"],
+                        }
+                    )
+
+        return primary_keys
+
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for SQLite."""
+        if not tables:
+            return []
+
+        indexes = []
+        for table in tables:
+            table_name = table["table_name"]
+
+            # Get index list using PRAGMA
+            pragma_query = f"PRAGMA index_list({table_name})"
+            table_indexes = await self._execute_query(connection, pragma_query)
+
+            for idx in table_indexes:
+                idx_name = idx["name"]
+                unique = bool(idx["unique"])
+
+                # Skip auto-generated primary key indexes
+                if idx_name.startswith("sqlite_autoindex_"):
+                    continue
+
+                # Get index columns using PRAGMA
+                pragma_info_query = f"PRAGMA index_info({idx_name})"
+                idx_cols = await self._execute_query(connection, pragma_info_query)
+                columns = [
+                    c["name"] for c in sorted(idx_cols, key=lambda r: r["seqno"])
+                ]
+
+                indexes.append(
+                    {
+                        "table_schema": "main",
+                        "table_name": table_name,
+                        "index_name": idx_name,
+                        "is_unique": unique,
+                        "index_type": None,  # SQLite only has B-tree currently
+                        "column_names": columns,
+                    }
+                )
+
+        return indexes
+
+    async def list_tables_info(self, connection) -> list[dict[str, Any]]:
+        """Get list of tables with basic information for SQLite."""
+        # Get table names without row counts for better performance
+        tables_query = """
+            SELECT
+                'main' as table_schema,
+                name as table_name,
+                type as table_type
+            FROM sqlite_master
+            WHERE type IN ('table', 'view')
+            AND name NOT LIKE 'sqlite_%'
+            ORDER BY name;
+        """
+
+        tables = await self._execute_query(connection, tables_query)
+
+        # Convert to expected format
+        return [
+            {
+                "table_schema": table["table_schema"],
+                "table_name": table["table_name"],
+                "table_type": table["table_type"],
+            }
+            for table in tables
+        ]

sqlsaber/mcp/mcp.py

@@ -6,7 +6,7 @@ from fastmcp import FastMCP
 
 from sqlsaber.agents.mcp import MCPSQLAgent
 from sqlsaber.config.database import DatabaseConfigManager
-from sqlsaber.database.connection import DatabaseConnection
+from sqlsaber.database import DatabaseConnection
 from sqlsaber.tools import SQLTool, tool_registry
 from sqlsaber.tools.instructions import InstructionBuilder
 

sqlsaber/tools/sql_tools.py

@@ -3,7 +3,7 @@
 import json
 from typing import Any
 
-from sqlsaber.database.connection import BaseDatabaseConnection
+from sqlsaber.database import BaseDatabaseConnection
 from sqlsaber.database.schema import SchemaManager
 
 from .base import Tool

{sqlsaber-0.25.0.dist-info → sqlsaber-0.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.25.0
+Version: 0.26.0
 Summary: SQLsaber - Open-source agentic SQL assistant
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -53,14 +53,15 @@ Ask your questions in natural language and `sqlsaber` will gather the right cont
 
 ## Features
 
-- 🔍 Automatic database schema introspection
-- 🛡️ Safe query execution (read-only by default)
-- 🧠 Memory management
-- 💬 Interactive REPL mode
-- 🧵 Conversation threads (store, display, and resume conversations)
-- 🗄️ Support for PostgreSQL, MySQL, SQLite, and DuckDB
-- 🔌 MCP (Model Context Protocol) server support
-- 🎨 Beautiful formatted output
+- Automatic database schema introspection
+- Safe query execution (read-only by default)
+- Memory management
+- Interactive REPL mode
+- Conversation threads (store, display, and resume conversations)
+- Support for PostgreSQL, MySQL, SQLite, DuckDB, and CSVs
+- MCP (Model Context Protocol) server support
+- Extended thinking mode for select models (Anthropic, OpenAI, Google, Groq)
+- Beautiful formatted output
 
 ## Installation
 
@@ -122,6 +123,39 @@ saber memory list
 
 > You can also add memories in an interactive query session by starting with the `#` sign
 
+### Extended Thinking Mode
+
+For complex queries that require deeper reasoning, `sqlsaber` supports extended thinking mode. When enabled, you will see the model's reasoning process as it generates SQL queries and arrives at conclusions.
+
+**Enable/disable via CLI flags:**
+
+```bash
+# Enable thinking for a single query
+saber --thinking "analyze sales trends across regions"
+
+# Disable thinking for a single query
+saber --no-thinking "show me all users"
+```
+
+**Toggle in interactive mode:**
+
+```bash
+# In interactive mode, use slash commands
+/thinking on   # Enable thinking
+/thinking off  # Disable thinking
+```
+
+**Configure default setting:**
+
+Thinking is disabled by default. To change the default, edit your config file at `~/.config/sqlsaber/model_config.json`:
+
+```json
+{
+  "model": "anthropic:claude-sonnet-4-20250514",
+  "thinking_enabled": true
+}
+```
+
 ## Usage
 
 ### Interactive Mode

sqlsaber-0.26.0.dist-info/RECORD

@@ -0,0 +1,52 @@
+sqlsaber/__init__.py,sha256=HjS8ULtP4MGpnTL7njVY45NKV9Fi4e_yeYuY-hyXWQc,73
+sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
+sqlsaber/agents/__init__.py,sha256=qYI6rLY4q5AbF47vXH5RVoM08-yQjymBSaePh4lFIW4,116
+sqlsaber/agents/base.py,sha256=40-MKEoz5rGrqVIylV1U2DaAUSPFcC75ohRin4E3-kk,2668
+sqlsaber/agents/mcp.py,sha256=Pn8tdDRUEVLYQyEi5nHRp9MKNePwHVVoeNI-uqWcr0Y,757
+sqlsaber/agents/pydantic_ai_agent.py,sha256=wBxKz0pjOkL-HI-TXV6B67bczZNgu7k26Rr3w5usR3o,10064
+sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
+sqlsaber/cli/auth.py,sha256=jTsRgbmlGPlASSuIKmdjjwfqtKvjfKd_cTYxX0-QqaQ,7400
+sqlsaber/cli/commands.py,sha256=n25CErTLgLeRSkoJI0Ickwtns5EH6O7RLVPgPs6UBxA,7986
+sqlsaber/cli/completers.py,sha256=g-hLDq5fiBx7gg8Bte1Lq8GU-ZxCYVs4dcPsmHPIcK4,6574
+sqlsaber/cli/database.py,sha256=qil7nZGWKm3tULL0cUsAQ_KvhU1oikK0XVh9MibrvP0,13413
+sqlsaber/cli/display.py,sha256=32QaNS0RDgRz93AVy6nPo9blahvMPEoVMFC5spzh0-Y,17041
+sqlsaber/cli/interactive.py,sha256=jGbWNNcEgZuQRZamc5tX5eIf1Rv1T6Sj5NI_WvonTrA,13624
+sqlsaber/cli/memory.py,sha256=OufHFJFwV0_GGn7LvKRTJikkWhV1IwNIUDOxFPHXOaQ,7794
+sqlsaber/cli/models.py,sha256=ZewtwGQwhd9b-yxBAPKePolvI1qQG-EkmeWAGMqtWNQ,8986
+sqlsaber/cli/streaming.py,sha256=YViLCxUv-7WN5TCphLYtAR02HXvuHYuPttGGDZKDUKU,6921
+sqlsaber/cli/threads.py,sha256=zVlbOuD3GjjEVNebXwANKeKt4I_Lunf6itiBUL0TaKA,12877
+sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
+sqlsaber/config/api_keys.py,sha256=RqWQCko1tY7sES7YOlexgBH5Hd5ne_kGXHdBDNqcV2U,3649
+sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
+sqlsaber/config/database.py,sha256=Yec6_0wdzq-ADblMNnbgvouYCimYOY_DWHT9oweaISc,11449
+sqlsaber/config/oauth_flow.py,sha256=A3bSXaBLzuAfXV2ZPA94m9NV33c2MyL6M4ii9oEkswQ,10291
+sqlsaber/config/oauth_tokens.py,sha256=C9z35hyx-PvSAYdC1LNf3rg9_wsEIY56hkEczelbad0,6015
+sqlsaber/config/providers.py,sha256=JFjeJv1K5Q93zWSlWq3hAvgch1TlgoF0qFa0KJROkKY,2957
+sqlsaber/config/settings.py,sha256=iB4CnGQ4hw8gxkaa9CVLB_JEy6Y9h9FQTAams5OCVyI,6421
+sqlsaber/database/__init__.py,sha256=Gi9N_NOkD459WRWXDg3hSuGoBs3xWbMDRBvsTVmnGAg,2025
+sqlsaber/database/base.py,sha256=yxYcfeNhRPbO5jFRVZH7eRUGj_up-y3p1ZX_obZXi0w,3552
+sqlsaber/database/csv.py,sha256=45eH9mAkBtwSu1Rc_vvG1Z40L4xvfHWSb8OMG15TbCA,4340
+sqlsaber/database/duckdb.py,sha256=v6gFUhih5NMbHHpUv7By2nXyl9aqdPtLt0zhqS4-OKE,11120
+sqlsaber/database/mysql.py,sha256=5qd9gnSCP3umtBJcQDTzzJfMzwqYCJhWlbOeJZ9_-6c,14349
+sqlsaber/database/postgresql.py,sha256=R8I3Y-w0P9qPe47-lmae0X17syIwI8saxEG3etx6Rqc,13097
+sqlsaber/database/resolver.py,sha256=wSCcn__aCqwIfpt_LCjtW2Zgb8RpG5PlmwwZHli1q_U,3628
+sqlsaber/database/schema.py,sha256=68PrNcA-5eR9PZB3i-TUQw5_E7QatwiDU2wv9GgXgM4,6928
+sqlsaber/database/sqlite.py,sha256=zdNj5i4mLJK21sWgftAHDHVihRUWevn__tVF9_nnLfQ,9297
+sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
+sqlsaber/mcp/mcp.py,sha256=tpNPHpkaCre1Xjp7c4DHXbTKeuYpDQ8qhmJZvAyr7Vk,3939
+sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
+sqlsaber/memory/manager.py,sha256=p3fybMVfH-E4ApT1ZRZUnQIWSk9dkfUPCyfkmA0HALs,2739
+sqlsaber/memory/storage.py,sha256=ne8szLlGj5NELheqLnI7zu21V8YS4rtpYGGC7tOmi-s,5745
+sqlsaber/threads/__init__.py,sha256=Hh3dIG1tuC8fXprREUpslCIgPYz8_6o7aRLx4yNeO48,139
+sqlsaber/threads/storage.py,sha256=rsUdxT4CR52D7xtGir9UlsFnBMk11jZeflzDrk2q4ME,11183
+sqlsaber/tools/__init__.py,sha256=x3YdmX_7P0Qq_HtZHAgfIVKTLxYqKk6oc4tGsujQWsc,586
+sqlsaber/tools/base.py,sha256=mHhvAj27BHmckyvuDLCPlAQdzABJyYxd9SJnaYAwwuA,1777
+sqlsaber/tools/enums.py,sha256=CH32mL-0k9ZA18911xLpNtsgpV6tB85TktMj6uqGz54,411
+sqlsaber/tools/instructions.py,sha256=X-x8maVkkyi16b6Tl0hcAFgjiYceZaSwyWTfmrvx8U8,9024
+sqlsaber/tools/registry.py,sha256=HWOQMsNIdL4XZS6TeNUyrL-5KoSDH6PHsWd3X66o-18,3211
+sqlsaber/tools/sql_tools.py,sha256=2xLD_pkd0t8wKndQAKIr4c9UpWzVWeHbAFpkwo5j4kY,9954
+sqlsaber-0.26.0.dist-info/METADATA,sha256=o4vaJVAG_1U5Tybcx2MY3lX0FvYjBEdKxFDWhFC9xYs,7138
+sqlsaber-0.26.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.26.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
+sqlsaber-0.26.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.26.0.dist-info/RECORD,,