sqlsaber 0.33.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

sqlsaber/application/auth_setup.py

@@ -1,6 +1,7 @@
 """Shared auth setup logic for onboarding and CLI."""
 
 import asyncio
+import os
 
 from questionary import Choice
 
@@ -9,6 +10,7 @@ from sqlsaber.config import providers
 from sqlsaber.config.api_keys import APIKeyManager
 from sqlsaber.config.auth import AuthConfigManager, AuthMethod
 from sqlsaber.config.oauth_flow import AnthropicOAuthFlow
+from sqlsaber.config.oauth_tokens import OAuthTokenManager
 from sqlsaber.theme.manager import create_console
 
 console = create_console()
@@ -102,24 +104,49 @@ async def setup_auth(
     Returns:
         Tuple of (success: bool, provider: str | None)
     """
-    # Check if auth is already configured
-    if auth_manager.has_auth_configured():
-        console.print("[success]✓ Authentication already configured![/success]")
-        return True, None
+    oauth_manager = OAuthTokenManager()
 
-    # Select provider
     provider = await select_provider(prompter, default=default_provider)
 
     if provider is None:
         return False, None
 
+    env_var = api_key_manager.get_env_var_name(provider)
+    api_key_in_env = bool(os.getenv(env_var))
+    api_key_in_keyring = api_key_manager.has_stored_api_key(provider)
+    has_oauth = (
+        oauth_manager.has_oauth_token("anthropic")
+        if provider == "anthropic" and allow_oauth
+        else False
+    )
+
+    if api_key_in_env or api_key_in_keyring or has_oauth:
+        parts: list[str] = []
+        if api_key_in_keyring:
+            parts.append("stored API key")
+        if api_key_in_env:
+            parts.append(f"{env_var} environment variable")
+        if has_oauth:
+            parts.append("OAuth token")
+        summary = ", ".join(parts)
+        console.print(
+            f"[info]Existing authentication found for {provider}: {summary}[/info]"
+        )
+
     # For Anthropic, offer OAuth or API key
     if provider == "anthropic" and allow_oauth:
+        api_key_label = "API Key"
+        if api_key_in_keyring or api_key_in_env:
+            api_key_label += " [configured]"
+        oauth_label = "Claude Pro/Max (OAuth)"
+        if has_oauth:
+            oauth_label += " [configured]"
+
         method_choice = await prompter.select(
             "Authentication method:",
             choices=[
-                Choice("API Key", value=AuthMethod.API_KEY),
-                Choice("Claude Pro/Max (OAuth)", value=AuthMethod.CLAUDE_PRO),
+                Choice(api_key_label, value=AuthMethod.API_KEY),
+                Choice(oauth_label, value=AuthMethod.CLAUDE_PRO),
             ],
         )
 
@@ -127,6 +154,28 @@ async def setup_auth(
             return False, None
 
         if method_choice == AuthMethod.CLAUDE_PRO:
+            if has_oauth:
+                reset = await prompter.confirm(
+                    "Anthropic OAuth is already configured. Reset before continuing?",
+                    default=False,
+                )
+                if not reset:
+                    console.print(
+                        "[warning]No changes made to Anthropic OAuth credentials.[/warning]"
+                    )
+                    return True, None
+
+                removal_success = oauth_manager.remove_oauth_token("anthropic")
+                if not removal_success:
+                    console.print(
+                        "[error]Failed to remove existing Anthropic OAuth credentials.[/error]"
+                    )
+                    return False, None
+
+                current_method = auth_manager.get_auth_method()
+                if current_method == AuthMethod.CLAUDE_PRO:
+                    auth_manager.clear_auth_method()
+
             console.print()
             oauth_success = await configure_oauth_anthropic(
                 auth_manager, run_in_thread=run_oauth_in_thread
@@ -136,12 +185,35 @@ async def setup_auth(
                     "[green]✓ Anthropic OAuth configured successfully![/green]"
                 )
                 return True, provider
-            else:
-                console.print("[error]✗ Anthropic OAuth setup failed.[/error]")
-                return False, None
+
+            console.print("[error]✗ Anthropic OAuth setup failed.[/error]")
+            return False, None
 
     # API key flow
-    env_var = api_key_manager.get_env_var_name(provider)
+    if api_key_in_keyring:
+        reset_api_key = await prompter.confirm(
+            f"{provider.title()} API key is stored in your keyring. Reset before continuing?",
+            default=False,
+        )
+        if not reset_api_key:
+            console.print(
+                "[warning]No changes made to stored API key credentials.[/warning]"
+            )
+            return True, None
+        if not api_key_manager.delete_api_key(provider):
+            console.print(
+                "[error]Failed to remove existing API key credentials.[/error]"
+            )
+            return False, None
+        console.print(
+            f"[muted]{provider.title()} API key removed from keyring.[/muted]"
+        )
+        api_key_in_keyring = False
+
+    if api_key_in_env:
+        console.print(
+            f"[muted]{env_var} is set in your environment. Update it there if you need a new value.[/muted]"
+        )
 
     console.print()
     console.print(f"[dim]To use {provider.title()}, you need an API key.[/dim]")

sqlsaber/cli/auth.py

@@ -167,7 +167,9 @@ def reset():
             pass
         except Exception as e:
             console.print(f"Warning: Could not remove API key: {e}", style="warning")
-            logger.warning("auth.reset.api_key_remove_failed", provider=provider, error=str(e))
+            logger.warning(
+                "auth.reset.api_key_remove_failed", provider=provider, error=str(e)
+            )
 
     # Optionally clear global auth method if removing Anthropic OAuth configuration
     if provider == "anthropic" and oauth_present:

sqlsaber/cli/display.py

@@ -406,9 +406,17 @@ class DisplayManager:
             for table_name, table_info in data.items():
                 self.console.print(f"\n[heading]Table: {table_name}[/heading]")
 
+                table_comment = table_info.get("comment")
+                if table_comment:
+                    self.console.print(f"[muted]Comment: {table_comment}[/muted]")
+
                 # Show columns
                 table_columns = table_info.get("columns", {})
                 if table_columns:
+                    include_column_comments = any(
+                        col_info.get("comment") for col_info in table_columns.values()
+                    )
+
                     # Create a table for columns
                     columns = [
                         {"name": "Column Name", "style": "column.name"},
@@ -416,6 +424,8 @@ class DisplayManager:
                         {"name": "Nullable", "style": "info"},
                         {"name": "Default", "style": "muted"},
                     ]
+                    if include_column_comments:
+                        columns.append({"name": "Comment", "style": "muted"})
                     col_table = self._create_table(columns, title="Columns")
 
                     for col_name, col_info in table_columns.items():
@@ -425,9 +435,15 @@ class DisplayManager:
                             if col_info.get("default")
                             else ""
                         )
-                        col_table.add_row(
-                            col_name, col_info.get("type", ""), nullable, default
-                        )
+                        row = [
+                            col_name,
+                            col_info.get("type", ""),
+                            nullable,
+                            default,
+                        ]
+                        if include_column_comments:
+                            row.append(col_info.get("comment") or "")
+                        col_table.add_row(*row)
 
                     self.console.print(col_table)
 

sqlsaber/cli/interactive.py

@@ -20,6 +20,7 @@ from sqlsaber.cli.completers import (
 )
 from sqlsaber.cli.display import DisplayManager
 from sqlsaber.cli.streaming import StreamingQueryHandler
+from sqlsaber.config.logging import get_logger
 from sqlsaber.database import (
     CSVConnection,
     DuckDBConnection,
@@ -30,7 +31,6 @@ from sqlsaber.database import (
 from sqlsaber.database.schema import SchemaManager
 from sqlsaber.theme.manager import get_theme_manager
 from sqlsaber.threads import ThreadStorage
-from sqlsaber.config.logging import get_logger
 
 if TYPE_CHECKING:
     from sqlsaber.agents.pydantic_ai_agent import SQLSaberAgent
@@ -309,6 +309,8 @@ class InteractiveSession:
                         style=self.tm.pt_style(),
                     )
 
+                user_query = user_query.strip()
+
                 if not user_query:
                     continue
 
@@ -325,7 +327,7 @@ class InteractiveSession:
 
                 # Handle memory addition
                 if user_query.strip().startswith("#"):
-                    await self._handle_memory(user_query.strip()[1:].strip())
+                    await self._handle_memory(user_query[1:].strip())
                     continue
 
                 # Execute query with cancellation support

sqlsaber/config/api_keys.py

@@ -41,6 +41,29 @@ class APIKeyManager:
         # 3. Prompt user for API key
         return self._prompt_and_store_key(provider, env_var_name, service_name)
 
+    def has_stored_api_key(self, provider: str) -> bool:
+        """Check if an API key is stored for the provider."""
+        service_name = self._get_service_name(provider)
+        try:
+            return keyring.get_password(service_name, provider) is not None
+        except Exception:
+            return False
+
+    def delete_api_key(self, provider: str) -> bool:
+        """Remove stored API key for the provider."""
+        service_name = self._get_service_name(provider)
+        try:
+            keyring.delete_password(service_name, provider)
+            return True
+        except keyring.errors.PasswordDeleteError:
+            return True
+        except Exception as e:
+            console.print(
+                f"Warning: Could not remove API key: {e}",
+                style="warning",
+            )
+            return False
+
     def get_env_var_name(self, provider: str) -> str:
         """Get the expected environment variable name for a provider."""
         # Normalize aliases to canonical provider keys

sqlsaber/config/auth.py

@@ -81,6 +81,12 @@ class AuthConfigManager:
         config["auth_method"] = auth_method.value
         self._save_config(config)
 
+    def clear_auth_method(self) -> None:
+        """Clear any configured authentication method."""
+        config = self._load_config()
+        config["auth_method"] = None
+        self._save_config(config)
+
     def has_auth_configured(self) -> bool:
         """Check if authentication method is configured."""
         return self.get_auth_method() is not None

sqlsaber/config/logging.py

@@ -193,4 +193,3 @@ __all__ = [
     "default_log_dir",
     "default_log_file",
 ]
-

sqlsaber/database/base.py

@@ -24,6 +24,7 @@ class ColumnInfo(TypedDict):
     max_length: int | None
     precision: int | None
     scale: int | None
+    comment: str | None
 
 
 class ForeignKeyInfo(TypedDict):
@@ -48,6 +49,7 @@ class SchemaInfo(TypedDict):
     schema: str
     name: str
     type: str
+    comment: str | None
     columns: dict[str, ColumnInfo]
     primary_keys: list[str]
     foreign_keys: list[ForeignKeyInfo]

sqlsaber/database/duckdb.py

@@ -132,29 +132,35 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
     ) -> list[dict[str, Any]]:
         """Get tables information for DuckDB."""
         where_conditions = [
-            "table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')"
+            "t.table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')"
         ]
         params: list[Any] = []
 
         if table_pattern:
             if "." in table_pattern:
                 schema_pattern, table_name_pattern = table_pattern.split(".", 1)
-                where_conditions.append("(table_schema LIKE ? AND table_name LIKE ?)")
+                where_conditions.append(
+                    "(t.table_schema LIKE ? AND t.table_name LIKE ?)"
+                )
                 params.extend([schema_pattern, table_name_pattern])
             else:
                 where_conditions.append(
-                    "(table_name LIKE ? OR table_schema || '.' || table_name LIKE ?)"
+                    "(t.table_name LIKE ? OR t.table_schema || '.' || t.table_name LIKE ?)"
                 )
                 params.extend([table_pattern, table_pattern])
 
         query = f"""
             SELECT
-                table_schema,
-                table_name,
-                table_type
-            FROM information_schema.tables
+                t.table_schema,
+                t.table_name,
+                t.table_type,
+                dt.comment AS table_comment
+            FROM information_schema.tables t
+            LEFT JOIN duckdb_tables() dt
+                ON t.table_schema = dt.schema_name
+                AND t.table_name = dt.table_name
             WHERE {" AND ".join(where_conditions)}
-            ORDER BY table_schema, table_name;
+            ORDER BY t.table_schema, t.table_name;
         """
 
         return await self._execute_query(connection, query, tuple(params))
@@ -166,7 +172,7 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
 
         table_filters = []
         for table in tables:
-            table_filters.append("(table_schema = ? AND table_name = ?)")
+            table_filters.append("(c.table_schema = ? AND c.table_name = ?)")
 
         params: list[Any] = []
         for table in tables:
@@ -174,18 +180,23 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
 
         query = f"""
             SELECT
-                table_schema,
-                table_name,
-                column_name,
-                data_type,
-                is_nullable,
-                column_default,
-                character_maximum_length,
-                numeric_precision,
-                numeric_scale
-            FROM information_schema.columns
+                c.table_schema,
+                c.table_name,
+                c.column_name,
+                c.data_type,
+                c.is_nullable,
+                c.column_default,
+                c.character_maximum_length,
+                c.numeric_precision,
+                c.numeric_scale,
+                dc.comment AS column_comment
+            FROM information_schema.columns c
+            LEFT JOIN duckdb_columns() dc
+                ON c.table_schema = dc.schema_name
+                AND c.table_name = dc.table_name
+                AND c.column_name = dc.column_name
             WHERE {" OR ".join(table_filters)}
-            ORDER BY table_schema, table_name, ordinal_position;
+            ORDER BY c.table_schema, c.table_name, c.ordinal_position;
         """
 
         return await self._execute_query(connection, query, tuple(params))
@@ -307,12 +318,16 @@ class DuckDBSchemaIntrospector(BaseSchemaIntrospector):
         """Get list of tables with basic information for DuckDB."""
         query = """
             SELECT
-                table_schema,
-                table_name,
-                table_type
-            FROM information_schema.tables
-            WHERE table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')
-            ORDER BY table_schema, table_name;
+                t.table_schema,
+                t.table_name,
+                t.table_type,
+                dt.comment AS table_comment
+            FROM information_schema.tables t
+            LEFT JOIN duckdb_tables() dt
+                ON t.table_schema = dt.schema_name
+                AND t.table_name = dt.table_name
+            WHERE t.table_schema NOT IN ('information_schema', 'pg_catalog', 'duckdb_catalog')
+            ORDER BY t.table_schema, t.table_name;
         """
 
         return await self._execute_query(connection, query)

sqlsaber/database/mysql.py

@@ -202,7 +202,8 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                     SELECT
                         table_schema,
                         table_name,
-                        table_type
+                        table_type,
+                        table_comment
                     FROM information_schema.tables
                     WHERE {" AND ".join(where_conditions)}
                     ORDER BY table_schema, table_name;
@@ -230,7 +231,8 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                         c.column_default,
                         c.character_maximum_length,
                         c.numeric_precision,
-                        c.numeric_scale
+                        c.numeric_scale,
+                        c.column_comment
                     FROM information_schema.columns c
                     WHERE (c.table_schema, c.table_name) IN ({placeholders})
                     ORDER BY c.table_schema, c.table_name, c.ordinal_position;
@@ -331,7 +333,8 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                     SELECT
                         t.table_schema,
                         t.table_name,
-                        t.table_type
+                        t.table_type,
+                        t.table_comment
                     FROM information_schema.tables t
                     WHERE t.table_schema NOT IN ('information_schema', 'performance_schema', 'mysql', 'sys')
                     ORDER BY t.table_schema, t.table_name;
@@ -345,6 +348,7 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                         "table_schema": row["table_schema"],
                         "table_name": row["table_name"],
                         "table_type": row["table_type"],
+                        "table_comment": row["table_comment"],
                     }
                     for row in rows
                 ]

sqlsaber/database/postgresql.py

@@ -135,6 +135,35 @@ class PostgreSQLConnection(BaseDatabaseConnection):
 class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
     """PostgreSQL-specific schema introspection."""
 
+    def _get_excluded_schemas(self) -> list[str]:
+        """Return schemas to exclude during introspection.
+
+        Defaults include PostgreSQL system schemas and TimescaleDB internal
+        partitions schema. Additional schemas can be excluded by setting the
+        environment variable `SQLSABER_PG_EXCLUDE_SCHEMAS` to a comma-separated
+        list of schema names.
+        """
+        import os
+
+        # Base exclusions: system schemas and TimescaleDB internal partitions
+        excluded = [
+            "pg_catalog",
+            "information_schema",
+            "_timescaledb_internal",
+            "_timescaledb_cache",
+            "_timescaledb_config",
+            "_timescaledb_catalog",
+        ]
+
+        extra = os.getenv("SQLSABER_PG_EXCLUDE_SCHEMAS", "")
+        if extra:
+            for item in extra.split(","):
+                name = item.strip()
+                if name and name not in excluded:
+                    excluded.append(name)
+
+        return excluded
+
     def _build_table_filter_clause(self, tables: list) -> tuple[str, list]:
         """Build VALUES clause with bind parameters for table filtering.
 
@@ -160,23 +189,35 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
         """Get tables information for PostgreSQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
-            # Build WHERE clause for filtering
-            where_conditions = [
-                "table_schema NOT IN ('pg_catalog', 'information_schema')"
-            ]
-            params = []
+            # Build WHERE clause for filtering with bind params
+            where_conditions: list[str] = []
+            params: list[Any] = []
+
+            excluded = self._get_excluded_schemas()
+            if excluded:
+                placeholders = ", ".join(f"${i + 1}" for i in range(len(excluded)))
+                where_conditions.append(f"table_schema NOT IN ({placeholders})")
+                params.extend(excluded)
+            else:
+                # Fallback safety
+                where_conditions.append(
+                    "table_schema NOT IN ('pg_catalog', 'information_schema')"
+                )
 
             if table_pattern:
                 # Support patterns like 'schema.table' or just 'table'
                 if "." in table_pattern:
                     schema_pattern, table_name_pattern = table_pattern.split(".", 1)
+                    s_idx = len(params) + 1
+                    t_idx = len(params) + 2
                     where_conditions.append(
-                        "(table_schema LIKE $1 AND table_name LIKE $2)"
+                        f"(table_schema LIKE ${s_idx} AND table_name LIKE ${t_idx})"
                     )
                     params.extend([schema_pattern, table_name_pattern])
                 else:
+                    p_idx = len(params) + 1
                     where_conditions.append(
-                        "(table_name LIKE $1 OR table_schema || '.' || table_name LIKE $1)"
+                        f"(table_name LIKE ${p_idx} OR table_schema || '.' || table_name LIKE ${p_idx})"
                     )
                     params.append(table_pattern)
 
@@ -185,7 +226,8 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
                 SELECT
                     table_schema,
                     table_name,
-                    table_type
+                    table_type,
+                    obj_description(('"' || table_schema || '"."' || table_name || '"')::regclass, 'pg_class') AS table_comment
                 FROM information_schema.tables
                 WHERE {" AND ".join(where_conditions)}
                 ORDER BY table_schema, table_name;
@@ -211,7 +253,8 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
                     c.column_default,
                     c.character_maximum_length,
                     c.numeric_precision,
-                    c.numeric_scale
+                    c.numeric_scale,
+                    col_description(('"' || c.table_schema || '"."' || c.table_name || '"')::regclass::oid, c.ordinal_position::INT) AS column_comment
                 FROM information_schema.columns c
                 WHERE (c.table_schema, c.table_name) IN (VALUES {values_clause})
                 ORDER BY c.table_schema, c.table_name, c.ordinal_position;
@@ -310,17 +353,29 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
         """Get list of tables with basic information for PostgreSQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
-            # Get table names and basic info without row counts for better performance
-            tables_query = """
+            # Exclude system schemas (and TimescaleDB internals) for performance
+            excluded = self._get_excluded_schemas()
+            params: list[Any] = []
+            if excluded:
+                placeholders = ", ".join(f"${i + 1}" for i in range(len(excluded)))
+                where_clause = f"table_schema NOT IN ({placeholders})"
+                params.extend(excluded)
+            else:
+                where_clause = (
+                    "table_schema NOT IN ('pg_catalog', 'information_schema')"
+                )
+
+            tables_query = f"""
                 SELECT
                     table_schema,
                     table_name,
-                    table_type
+                    table_type,
+                    obj_description(('"' || table_schema || '"."' || table_name || '"')::regclass, 'pg_class') AS table_comment
                 FROM information_schema.tables
-                WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+                WHERE {where_clause}
                 ORDER BY table_schema, table_name;
             """
-            tables = await conn.fetch(tables_query)
+            tables = await conn.fetch(tables_query, *params)
 
             # Convert to expected format
             return [
@@ -328,6 +383,7 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
                     "table_schema": table["table_schema"],
                     "table_name": table["table_name"],
                     "table_type": table["table_type"],
+                    "table_comment": table["table_comment"],
                 }
                 for table in tables
             ]

sqlsaber/database/schema.py

@@ -72,6 +72,7 @@ class SchemaManager:
                 "schema": schema_name,
                 "name": table_name,
                 "type": table["table_type"],
+                "comment": table["table_comment"],
                 "columns": {},
                 "primary_keys": [],
                 "foreign_keys": [],
@@ -85,6 +86,7 @@ class SchemaManager:
         for col in columns:
             full_name = f"{col['table_schema']}.{col['table_name']}"
             if full_name in schema_info:
+                # Handle different row types (dict vs Row objects)
                 column_info: ColumnInfo = {
                     "data_type": col["data_type"],
                     "nullable": col.get("is_nullable", "YES") == "YES",
@@ -92,6 +94,7 @@ class SchemaManager:
                     "max_length": col.get("character_maximum_length"),
                     "precision": col.get("numeric_precision"),
                     "scale": col.get("numeric_scale"),
+                    "comment": col.get("column_comment"),
                 }
                 # Add type field for display compatibility
                 column_info["type"] = col["data_type"]

sqlsaber/database/sqlite.py

@@ -93,7 +93,10 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
     async def get_tables_info(
         self, connection, table_pattern: str | None = None
     ) -> dict[str, Any]:
-        """Get tables information for SQLite."""
+        """Get tables information for SQLite.
+
+        Note: SQLite does not support native table comments, so table_comment is always None.
+        """
         where_conditions = ["type IN ('table', 'view')", "name NOT LIKE 'sqlite_%'"]
         params = ()
 
@@ -105,7 +108,8 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
             SELECT
                 'main' as table_schema,
                 name as table_name,
-                type as table_type
+                type as table_type,
+                NULL as table_comment
             FROM sqlite_master
             WHERE {" AND ".join(where_conditions)}
             ORDER BY name;
@@ -114,7 +118,10 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
         return await self._execute_query(connection, query, params)
 
     async def get_columns_info(self, connection, tables: list) -> list:
-        """Get columns information for SQLite."""
+        """Get columns information for SQLite.
+
+        Note: SQLite does not support native column comments, so column_comment is always None.
+        """
         if not tables:
             return []
 
@@ -138,6 +145,7 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
                         "character_maximum_length": None,
                         "numeric_precision": None,
                         "numeric_scale": None,
+                        "column_comment": None,
                     }
                 )
 
@@ -237,13 +245,17 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
         return indexes
 
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
-        """Get list of tables with basic information for SQLite."""
+        """Get list of tables with basic information for SQLite.
+
+        Note: SQLite does not support native table comments, so table_comment is always None.
+        """
         # Get table names without row counts for better performance
         tables_query = """
             SELECT
                 'main' as table_schema,
                 name as table_name,
-                type as table_type
+                type as table_type,
+                NULL as table_comment
             FROM sqlite_master
             WHERE type IN ('table', 'view')
             AND name NOT LIKE 'sqlite_%'
@@ -258,6 +270,7 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
                 "table_schema": table["table_schema"],
                 "table_name": table["table_name"],
                 "table_type": table["table_type"],
+                "table_comment": table["table_comment"],
             }
             for table in tables
         ]

sqlsaber/tools/sql_tools.py

@@ -95,27 +95,38 @@ class IntrospectSchemaTool(SQLTool):
             # Format the schema information
             formatted_info = {}
             for table_name, table_info in schema_info.items():
-                formatted_info[table_name] = {
-                    "columns": {
-                        col_name: {
-                            "type": col_info["data_type"],
-                            "nullable": col_info["nullable"],
-                            "default": col_info["default"],
-                        }
-                        for col_name, col_info in table_info["columns"].items()
-                    },
-                    "primary_keys": table_info["primary_keys"],
-                    "foreign_keys": [
-                        f"{fk['column']} -> {fk['references']['table']}.{fk['references']['column']}"
-                        for fk in table_info["foreign_keys"]
-                    ],
-                    "indexes": [
-                        f"{idx['name']} ({', '.join(idx['columns'])})"
-                        + (" UNIQUE" if idx["unique"] else "")
-                        + (f" [{idx['type']}]" if idx["type"] else "")
-                        for idx in table_info["indexes"]
-                    ],
-                }
+                table_data = {}
+
+                # Add table comment if present
+                if table_info.get("comment"):
+                    table_data["comment"] = table_info["comment"]
+
+                # Add columns with comments if present
+                table_data["columns"] = {}
+                for col_name, col_info in table_info["columns"].items():
+                    column_data = {
+                        "type": col_info["data_type"],
+                        "nullable": col_info["nullable"],
+                        "default": col_info["default"],
+                    }
+                    if col_info.get("comment"):
+                        column_data["comment"] = col_info["comment"]
+                    table_data["columns"][col_name] = column_data
+
+                # Add other schema information
+                table_data["primary_keys"] = table_info["primary_keys"]
+                table_data["foreign_keys"] = [
+                    f"{fk['column']} -> {fk['references']['table']}.{fk['references']['column']}"
+                    for fk in table_info["foreign_keys"]
+                ]
+                table_data["indexes"] = [
+                    f"{idx['name']} ({', '.join(idx['columns'])})"
+                    + (" UNIQUE" if idx["unique"] else "")
+                    + (f" [{idx['type']}]" if idx["type"] else "")
+                    for idx in table_info["indexes"]
+                ]
+
+                formatted_info[table_name] = table_data
 
             return json.dumps(formatted_info)
         except Exception as e:

{sqlsaber-0.33.0.dist-info → sqlsaber-0.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.33.0
+Version: 0.35.0
 Summary: SQLsaber - Open-source agentic SQL assistant
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlsaber-0.33.0.dist-info → sqlsaber-0.35.0.dist-info}/RECORD

@@ -4,17 +4,17 @@ sqlsaber/agents/__init__.py,sha256=qYI6rLY4q5AbF47vXH5RVoM08-yQjymBSaePh4lFIW4,1
 sqlsaber/agents/base.py,sha256=T05UsMZPwAlMhsJFpuuVI1RNDhdiwiEsgCWr9MbPoAU,2654
 sqlsaber/agents/pydantic_ai_agent.py,sha256=6_KppII8YcMw74KOGsYI5Dt6AP8WSduK3yAXCawVex4,10643
 sqlsaber/application/__init__.py,sha256=KY_-d5nEdQyAwNOsK5r-f7Tb69c63XbuEkHPeLpJal8,84
-sqlsaber/application/auth_setup.py,sha256=D94dyU9bOVfnNHLnnFJb5PaeWsKPTL21CiS_DLcY93A,5114
+sqlsaber/application/auth_setup.py,sha256=wbi9MaYl6q27LjcSBZmqFC12JtE5hrUHEX1NmD-7UVc,7778
 sqlsaber/application/db_setup.py,sha256=ZSgR9rJJVHttIjsbYQS9GEIyzkM09k5RLrVGdegrfYc,6859
 sqlsaber/application/model_selection.py,sha256=fSC06MZNKinHDR-csMFVYYJFyK8MydKf6pStof74Jp0,3191
 sqlsaber/application/prompts.py,sha256=4rMGcWpYJbNWPMzqVWseUMx0nwvXOkWS6GaTAJ5mhfc,3473
 sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
-sqlsaber/cli/auth.py,sha256=eCHxNO2IzgW7Og5970Yc9NZO5PPq1b2WpqVqEXDa66w,7021
+sqlsaber/cli/auth.py,sha256=TmAD4BJr2gIjPeW2LA1QkKK5gUZ2OOS6vOmBvB6PC0M,7051
 sqlsaber/cli/commands.py,sha256=WocWlLrxA5kM8URfvIvWFtc0ocfgKWAwoYTxVNZhmM4,10962
 sqlsaber/cli/completers.py,sha256=g-hLDq5fiBx7gg8Bte1Lq8GU-ZxCYVs4dcPsmHPIcK4,6574
 sqlsaber/cli/database.py,sha256=BBGj0eyduh5DDXNLZLDtWfY9kWpeT_ZX0J9R9INZyyU,12421
-sqlsaber/cli/display.py,sha256=WB5JCumhXadziDEX1EZHG3vN1Chol5FNAaTXHieqFK0,17892
-sqlsaber/cli/interactive.py,sha256=XSl_W1NOozFfxf3On5r6w53qMNULyttHnH4vR4iQGus,14140
+sqlsaber/cli/display.py,sha256=wxkEFceyyUloDUB49Gzqhl6JGRGq2cQdmJ3XQeYd6ok,18599
+sqlsaber/cli/interactive.py,sha256=bqeQVUgghKeZdsZ31LTcUTNt_jYyc2ujnAlUNRpxF5c,14181
 sqlsaber/cli/memory.py,sha256=kAY5LLFueIF30gJ8ibfrFw42rOyy5wajeJGS4h5XQw4,9475
 sqlsaber/cli/models.py,sha256=aVHazP_fiT-Mj9AtCdjliDtq3E3fJrhgP4oF5p4CuwI,9593
 sqlsaber/cli/onboarding.py,sha256=iBGT-W-OJFRvQoEpuHYyO1c9Mym5c97eIefRvxGHtTg,11265
@@ -22,23 +22,23 @@ sqlsaber/cli/streaming.py,sha256=jicSDLWQ3efitpdc2y4QsasHcEW8ogZ4lHcWmftq9Ao,676
 sqlsaber/cli/theme.py,sha256=D6HIt7rmF00B5ZOCV5lXKzPICE4uppHdraOdVs7k5Nw,4672
 sqlsaber/cli/threads.py,sha256=zYvs1epmRRuQxOofF85eXk1_YHS6co7oq_F33DdNdf0,14643
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
-sqlsaber/config/api_keys.py,sha256=dJ7cCSFOM6CRLHxEVgKJXGIOd_wQkRuQO4W88-8ng_w,3672
-sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
+sqlsaber/config/api_keys.py,sha256=H7xBU1mflngXIlnaDjbTvuNqZsW_92AIve31eDLij34,4513
+sqlsaber/config/auth.py,sha256=G1uulySUclWSId8EIt1hPNmsUNhbfRzfp8VVQftYyG8,2964
 sqlsaber/config/database.py,sha256=Yec6_0wdzq-ADblMNnbgvouYCimYOY_DWHT9oweaISc,11449
-sqlsaber/config/logging.py,sha256=V-DGhKm7XYPtcA6bXL-aQQyTTlyHi2WHTqTTzu2xipw,6174
+sqlsaber/config/logging.py,sha256=vv4oCuQePeYQ7bMs0OLKj8ZSiNcFWbHmWtdC0lTsUyc,6173
 sqlsaber/config/oauth_flow.py,sha256=cDfaJjqr4spNuzxbAlzuJfk6SEe1ojSRAkoOWlvQYy0,11037
 sqlsaber/config/oauth_tokens.py,sha256=KCC2u3lOjdh0M-rd0K1rW0PWk58w7mqpodAhlPVp9NE,6424
 sqlsaber/config/providers.py,sha256=JFjeJv1K5Q93zWSlWq3hAvgch1TlgoF0qFa0KJROkKY,2957
 sqlsaber/config/settings.py,sha256=-nIBNt9E0tCRGd14bk4x-bNAwO12sbsjRsN8fFannK4,6449
 sqlsaber/database/__init__.py,sha256=Gi9N_NOkD459WRWXDg3hSuGoBs3xWbMDRBvsTVmnGAg,2025
-sqlsaber/database/base.py,sha256=oaipLxlvoylX6oJCITPAWWqRqv09hRELqqEBufsmFic,3703
+sqlsaber/database/base.py,sha256=ZxbDuk0W-3edo6aN2EZ65SMQ3Oxiud_jygc4ZWi2CmI,3751
 sqlsaber/database/csv.py,sha256=41wuP40FaGPfj28HMiD0I69uG0JbUxArpoTLC3MG2uc,4464
-sqlsaber/database/duckdb.py,sha256=8HNKdx208aFK_YtwGjLz6LTne0xEmNevD-f9dRWlrFg,11244
-sqlsaber/database/mysql.py,sha256=wMzDQqq4GFbfEdqXtv_sCb4Qbr9GSWqYAvOLeo5UryY,14472
-sqlsaber/database/postgresql.py,sha256=fuf2Wl29NKXvD3mqsR08PDleNQ1PG-fNvWSxT6HDh2M,13223
+sqlsaber/database/duckdb.py,sha256=zGa1akNzG1Jreyhq6jm93iFzmPtOC8WcS-7TtQxzxME,11961
+sqlsaber/database/mysql.py,sha256=wZ98wrA9E7hljGAcz5h4zBJdRJ0uPdvTZQmFqQVXDBk,14657
+sqlsaber/database/postgresql.py,sha256=0fyko76pEdn5GxtaW75lwf8OIKnj2NnaY7Z1j_heUNs,15685
 sqlsaber/database/resolver.py,sha256=wSCcn__aCqwIfpt_LCjtW2Zgb8RpG5PlmwwZHli1q_U,3628
-sqlsaber/database/schema.py,sha256=CuV0ewoVaERe1gj_fJFJFWAP8aEPgepmn6X6B7bgkfQ,6962
-sqlsaber/database/sqlite.py,sha256=iReEIiSpkhhS1VzITd79ZWqSL3fHMyfe3DRCDpM0DvE,9421
+sqlsaber/database/schema.py,sha256=T4dEYOk-Cy5XkhvvQ3GqAU2w584eRivbiu9UZ0nHTBo,7138
+sqlsaber/database/sqlite.py,sha256=juEVIhSwbeT0gMkEhkjwNUJn-Mif_IIDmXVqostNT-o,9918
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
 sqlsaber/memory/manager.py,sha256=p3fybMVfH-E4ApT1ZRZUnQIWSk9dkfUPCyfkmA0HALs,2739
 sqlsaber/memory/storage.py,sha256=ne8szLlGj5NELheqLnI7zu21V8YS4rtpYGGC7tOmi-s,5745
@@ -54,9 +54,9 @@ sqlsaber/tools/__init__.py,sha256=O6eqkMk8mkhYDniQD1eYgAElOjiHz03I2bGARdgkDkk,42
 sqlsaber/tools/base.py,sha256=NKEEooliPKTJj_Pomwte_wW0Xd9Z5kXNfVdCRfTppuw,883
 sqlsaber/tools/registry.py,sha256=XmBzERq0LJXtg3BZ-r8cEyt8J54NUekgUlTJ_EdSYMk,2204
 sqlsaber/tools/sql_guard.py,sha256=dTDwcZP-N4xPGzcr7MQtKUxKrlDzlc1irr9aH5a4wvk,6182
-sqlsaber/tools/sql_tools.py,sha256=eo-NTxiXGHMopAjujvDDjmv9hf5bQNbiy3nTpxoJ_E8,7369
-sqlsaber-0.33.0.dist-info/METADATA,sha256=mmok25Vmy-2XivaKzRa3n5LD7FFNCEqa3i0roHUq-QE,5915
-sqlsaber-0.33.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.33.0.dist-info/entry_points.txt,sha256=tw1mB0fjlkXQiOsC0434X6nE-o1cFCuQwt2ZYHv_WAE,91
-sqlsaber-0.33.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.33.0.dist-info/RECORD,,
+sqlsaber/tools/sql_tools.py,sha256=q479PNneuAlpaDCp2cyw1MFhLUY4vcUHV_ZyIuSMHK0,7796
+sqlsaber-0.35.0.dist-info/METADATA,sha256=2TaG6of-RcfHsYWODoipU909C40Kfq2qaWRE71sI85M,5915
+sqlsaber-0.35.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.35.0.dist-info/entry_points.txt,sha256=tw1mB0fjlkXQiOsC0434X6nE-o1cFCuQwt2ZYHv_WAE,91
+sqlsaber-0.35.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.35.0.dist-info/RECORD,,