sqlsaber 0.22.0__tar.gz → 0.24.0__tar.gz

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/PKG-INFO

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

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/docs/src/content/docs/changelog.md

@@ -7,6 +7,21 @@ All notable changes to SQLsaber will be documented here.
 
 ### Unreleased
 
+### v0.24.0 - 2025-09-24
+
+#### Added
+
+- Index information is now included in `introspect_schema` tool output alongside columns, primary keys, and foreign keys
+- Cleaner markdown formatting for thread exports when redirected to files
+  - Terminal display remains unchanged with rich styling and colors
+
+### v0.23.0 - 2025-09-16
+
+#### Added
+
+- Smoother markdown streaming and prevent duplicate messages
+- SQL execution errors now display in interactive sessions instead of being silently dropped
+
 ### v0.22.0 - 2025-09-15
 
 #### Added

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/docs/src/content/docs/index.mdx

@@ -25,8 +25,8 @@ import {
 } from "@astrojs/starlight/components";
 
 <script
-  src="https://asciinema.org/a/739399.js"
-  id="asciicast-739399"
+  src="https://asciinema.org/a/741230.js"
+  id="asciicast-741230"
   async="true"
 ></script>
 

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlsaber"
-version = "0.22.0"
+version = "0.24.0"
 description = "SQLsaber - Open-source agentic SQL assistant"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/src/sqlsaber/cli/display.py

@@ -93,12 +93,15 @@ class LiveMarkdownRenderer:
         """Finalize and stop the current Live segment, if any."""
         if self._live is None:
             return
-        if self._buffer:
-            self._live.update(Markdown(self._buffer))
+        # Persist the *final* render exactly once, then shut Live down.
+        buf = self._buffer
         self._live.stop()
         self._live = None
         self._buffer = ""
         self._current_kind = None
+        # Print the complete markdown to scroll-back for permanent reference
+        if buf:
+            self.console.print(Markdown(buf))
 
     def end_if_active(self) -> None:
         self.end()
@@ -154,10 +157,12 @@ class LiveMarkdownRenderer:
         if self._live is not None:
             self.end()
         self._buffer = initial_markdown or ""
+        # NOTE: Use transient=True so the live widget disappears on exit,
+        # giving a clean transition to the final printed result.
         live = Live(
             Markdown(self._buffer),
             console=self.console,
-            vertical_overflow="visible",
+            transient=True,
             refresh_per_second=12,
         )
         self._live = live
@@ -193,22 +198,32 @@ class DisplayManager:
         # Normalized leading blank line before tool headers
         self.show_newline()
         if tool_name == "list_tables":
-            self.console.print(
-                "[dim bold]:gear: Discovering available tables[/dim bold]"
-            )
+            if self.console.is_terminal:
+                self.console.print(
+                    "[dim bold]:gear: Discovering available tables[/dim bold]"
+                )
+            else:
+                self.console.print("**Discovering available tables**\n")
         elif tool_name == "introspect_schema":
             pattern = tool_input.get("table_pattern", "all tables")
-            self.console.print(
-                f"[dim bold]:gear: Examining schema for: {pattern}[/dim bold]"
-            )
+            if self.console.is_terminal:
+                self.console.print(
+                    f"[dim bold]:gear: Examining schema for: {pattern}[/dim bold]"
+                )
+            else:
+                self.console.print(f"**Examining schema for:** {pattern}\n")
         elif tool_name == "execute_sql":
             # For streaming, we render SQL via LiveMarkdownRenderer; keep Syntax
             # rendering for threads show/resume. Controlled by include_sql flag.
             query = tool_input.get("query", "")
-            self.console.print("[dim bold]:gear: Executing SQL:[/dim bold]")
-            self.show_newline()
-            syntax = Syntax(query, "sql", background_color="default", word_wrap=True)
-            self.console.print(syntax)
+            if self.console.is_terminal:
+                self.console.print("[dim bold]:gear: Executing SQL:[/dim bold]")
+                self.show_newline()
+                syntax = Syntax(query, "sql", background_color="default", word_wrap=True)
+                self.console.print(syntax)
+            else:
+                self.console.print("**Executing SQL:**\n")
+                self.console.print(f"```sql\n{query}\n```\n")
 
     def show_text_stream(self, text: str):
         """Display streaming text."""
@@ -220,9 +235,12 @@ class DisplayManager:
         if not results:
             return
 
-        self.console.print(
-            f"\n[bold magenta]Results ({len(results)} rows):[/bold magenta]"
-        )
+        if self.console.is_terminal:
+            self.console.print(
+                f"\n[bold magenta]Results ({len(results)} rows):[/bold magenta]"
+            )
+        else:
+            self.console.print(f"\n**Results ({len(results)} rows):**\n")
 
         # Create table with columns from first result
         all_columns = list(results[0].keys())
@@ -230,9 +248,14 @@ class DisplayManager:
 
         # Show warning if columns were truncated
         if len(all_columns) > 15:
-            self.console.print(
-                f"[yellow]Note: Showing first 15 of {len(all_columns)} columns[/yellow]"
-            )
+            if self.console.is_terminal:
+                self.console.print(
+                    f"[yellow]Note: Showing first 15 of {len(all_columns)} columns[/yellow]"
+                )
+            else:
+                self.console.print(
+                    f"*Note: Showing first 15 of {len(all_columns)} columns*\n"
+                )
 
         table = self._create_table(display_columns)
 
@@ -243,14 +266,28 @@ class DisplayManager:
         self.console.print(table)
 
         if len(results) > 20:
-            self.console.print(
-                f"[yellow]... and {len(results) - 20} more rows[/yellow]"
-            )
+            if self.console.is_terminal:
+                self.console.print(
+                    f"[yellow]... and {len(results) - 20} more rows[/yellow]"
+                )
+            else:
+                self.console.print(
+                    f"*... and {len(results) - 20} more rows*\n"
+                )
 
     def show_error(self, error_message: str):
         """Display error message."""
         self.console.print(f"\n[bold red]Error:[/bold red] {error_message}")
 
+    def show_sql_error(self, error_message: str, suggestions: list[str] | None = None):
+        """Display SQL-specific error with optional suggestions."""
+        self.show_newline()
+        self.console.print(f"[bold red]SQL error:[/bold red] {error_message}")
+        if suggestions:
+            self.console.print("[yellow]Hints:[/yellow]")
+            for suggestion in suggestions:
+                self.console.print(f"  • {suggestion}")
+
     def show_processing(self, message: str):
         """Display processing message."""
         self.console.print()  # Add newline
@@ -371,6 +408,13 @@ class DisplayManager:
                     for fk in foreign_keys:
                         self.console.print(f"  • {fk}")
 
+                # Show indexes
+                indexes = table_info.get("indexes", [])
+                if indexes:
+                    self.console.print("[bold blue]Indexes:[/bold blue]")
+                    for idx in indexes:
+                        self.console.print(f"  • {idx}")
+
         except json.JSONDecodeError:
             self.show_error("Failed to parse schema data")
         except Exception as e:

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/src/sqlsaber/cli/streaming.py

@@ -114,8 +114,14 @@ class StreamingQueryHandler:
                         pass
             elif isinstance(content, dict):
                 data = content
-            if isinstance(data, dict) and data.get("success") and data.get("results"):
-                self.display.show_query_results(data["results"])  # type: ignore[arg-type]
+
+            if isinstance(data, dict):
+                if data.get("success") and data.get("results"):
+                    self.display.show_query_results(data["results"])  # type: ignore[arg-type]
+                elif "error" in data:
+                    self.display.show_sql_error(
+                        data.get("error"), data.get("suggestions")
+                    )
         # Add a blank line after tool output to separate from next segment
         self.display.show_newline()
         # Show status while agent sends a follow-up request to the model

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/src/sqlsaber/cli/threads.py

@@ -38,6 +38,8 @@ def _render_transcript(
     from sqlsaber.cli.display import DisplayManager
 
     dm = DisplayManager(console)
+    # Check if output is being redirected (for clean markdown export)
+    is_redirected = not console.is_terminal
 
     # Locate indices of user prompts
     user_indices: list[int] = []
@@ -78,11 +80,17 @@ def _render_transcript(
                                 parts.append(str(seg))
                     text = "\n".join([s for s in parts if s]) or None
                 if text:
-                    console.print(
-                        Panel.fit(Markdown(text), title="User", border_style="cyan")
-                    )
+                    if is_redirected:
+                        console.print(f"**User:**\n\n{text}\n")
+                    else:
+                        console.print(
+                            Panel.fit(Markdown(text), title="User", border_style="cyan")
+                        )
                     return
-        console.print(Panel.fit("(no content)", title="User", border_style="cyan"))
+        if is_redirected:
+            console.print("**User:** (no content)\n")
+        else:
+            console.print(Panel.fit("(no content)", title="User", border_style="cyan"))
 
     def _render_response(message: ModelMessage) -> None:
         for part in getattr(message, "parts", []):
@@ -90,11 +98,14 @@ def _render_transcript(
             if kind == "text":
                 text = getattr(part, "content", "")
                 if isinstance(text, str) and text.strip():
-                    console.print(
-                        Panel.fit(
-                            Markdown(text), title="Assistant", border_style="green"
+                    if is_redirected:
+                        console.print(f"**Assistant:**\n\n{text}\n")
+                    else:
+                        console.print(
+                            Panel.fit(
+                                Markdown(text), title="Assistant", border_style="green"
+                            )
                         )
-                    )
             elif kind in ("tool-call", "builtin-tool-call"):
                 name = getattr(part, "tool_name", "tool")
                 args = getattr(part, "args", None)
@@ -131,6 +142,24 @@ def _render_transcript(
                             and data.get("results")
                         ):
                             dm.show_query_results(data["results"])  # type: ignore[arg-type]
+                        elif isinstance(data, dict) and "error" in data:
+                            dm.show_sql_error(
+                                data.get("error"), data.get("suggestions")
+                            )
+                        else:
+                            if is_redirected:
+                                console.print(f"**Tool result ({name}):**\n\n{content_str}\n")
+                            else:
+                                console.print(
+                                    Panel.fit(
+                                        content_str,
+                                        title=f"Tool result: {name}",
+                                        border_style="yellow",
+                                    )
+                                )
+                    except Exception:
+                        if is_redirected:
+                            console.print(f"**Tool result ({name}):**\n\n{content_str}\n")
                         else:
                             console.print(
                                 Panel.fit(
@@ -139,7 +168,10 @@ def _render_transcript(
                                     border_style="yellow",
                                 )
                             )
-                    except Exception:
+                else:
+                    if is_redirected:
+                        console.print(f"**Tool result ({name}):**\n\n{content_str}\n")
+                    else:
                         console.print(
                             Panel.fit(
                                 content_str,
@@ -147,14 +179,6 @@ def _render_transcript(
                                 border_style="yellow",
                             )
                         )
-                else:
-                    console.print(
-                        Panel.fit(
-                            content_str,
-                            title=f"Tool result: {name}",
-                            border_style="yellow",
-                        )
-                    )
         # Thinking parts omitted
 
     for start_idx, end_idx in slices or [(0, len(all_msgs))]:
@@ -266,7 +290,10 @@ def resume(
         try:
             agent = build_sqlsaber_agent(db_conn, db_name)
             history = await store.get_thread_messages(thread_id)
-            console.print(Panel.fit(f"Thread: {thread.id}", border_style="blue"))
+            if console.is_terminal:
+                console.print(Panel.fit(f"Thread: {thread.id}", border_style="blue"))
+            else:
+                console.print(f"# Thread: {thread.id}\n")
             _render_transcript(console, history, None)
             session = InteractiveSession(
                 console=console,

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/src/sqlsaber/database/schema.py

@@ -32,6 +32,15 @@ class ForeignKeyInfo(TypedDict):
     references: dict[str, str]  # {"table": "schema.table", "column": "column_name"}
 
 
+class IndexInfo(TypedDict):
+    """Type definition for index information."""
+
+    name: str
+    columns: list[str]  # ordered
+    unique: bool
+    type: str | None  # btree, gin, FULLTEXT, etc. None if unknown
+
+
 class SchemaInfo(TypedDict):
     """Type definition for schema information."""
 
@@ -41,6 +50,7 @@ class SchemaInfo(TypedDict):
     columns: dict[str, ColumnInfo]
     primary_keys: list[str]
     foreign_keys: list[ForeignKeyInfo]
+    indexes: list[IndexInfo]
 
 
 class BaseSchemaIntrospector(ABC):
@@ -68,6 +78,11 @@ class BaseSchemaIntrospector(ABC):
         """Get primary keys information for the specific database type."""
         pass
 
+    @abstractmethod
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for the specific database type."""
+        pass
+
     @abstractmethod
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information."""
@@ -209,6 +224,43 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
             """
             return await conn.fetch(pk_query)
 
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for PostgreSQL."""
+        if not tables:
+            return []
+
+        pool = await connection.get_pool()
+        async with pool.acquire() as conn:
+            # Build proper table filters
+            idx_table_filters = []
+            for table in tables:
+                idx_table_filters.append(
+                    f"(ns.nspname = '{table['table_schema']}' AND t.relname = '{table['table_name']}')"
+                )
+
+            idx_query = f"""
+                SELECT
+                    ns.nspname      AS table_schema,
+                    t.relname       AS table_name,
+                    i.relname       AS index_name,
+                    ix.indisunique  AS is_unique,
+                    am.amname       AS index_type,
+                    array_agg(a.attname ORDER BY ord.ordinality) AS column_names
+                FROM pg_class t
+                JOIN pg_namespace ns     ON ns.oid = t.relnamespace
+                JOIN pg_index    ix      ON ix.indrelid = t.oid
+                JOIN pg_class    i       ON i.oid  = ix.indexrelid
+                JOIN pg_am       am      ON am.oid = i.relam
+                JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS ord(attnum, ordinality)
+                     ON TRUE
+                JOIN pg_attribute a      ON a.attrelid = t.oid AND a.attnum = ord.attnum
+                WHERE ns.nspname NOT IN ('pg_catalog', 'information_schema')
+                  AND ({" OR ".join(idx_table_filters)})
+                GROUP BY table_schema, table_name, index_name, is_unique, index_type
+                ORDER BY table_schema, table_name, index_name;
+            """
+            return await conn.fetch(idx_query)
+
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for PostgreSQL."""
         pool = await connection.get_pool()
@@ -379,6 +431,37 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                 await cursor.execute(pk_query)
                 return await cursor.fetchall()
 
+    async def get_indexes_info(self, connection, tables: list) -> list:
+        """Get indexes information for MySQL."""
+        if not tables:
+            return []
+
+        pool = await connection.get_pool()
+        async with pool.acquire() as conn:
+            async with conn.cursor() as cursor:
+                # Build proper table filters
+                idx_table_filters = []
+                for table in tables:
+                    idx_table_filters.append(
+                        f"(TABLE_SCHEMA = '{table['table_schema']}' AND TABLE_NAME = '{table['table_name']}')"
+                    )
+
+                idx_query = f"""
+                    SELECT
+                        TABLE_SCHEMA   AS table_schema,
+                        TABLE_NAME     AS table_name,
+                        INDEX_NAME     AS index_name,
+                        (NON_UNIQUE = 0) AS is_unique,
+                        INDEX_TYPE     AS index_type,
+                        GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) AS column_names
+                    FROM INFORMATION_SCHEMA.STATISTICS
+                    WHERE ({" OR ".join(idx_table_filters)})
+                    GROUP BY table_schema, table_name, index_name, is_unique, index_type
+                    ORDER BY table_schema, table_name, index_name;
+                """
+                await cursor.execute(idx_query)
+                return await cursor.fetchall()
+
     async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for MySQL."""
         pool = await connection.get_pool()
@@ -531,6 +614,47 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
         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
@@ -589,12 +713,14 @@ class SchemaManager:
         columns = await self.introspector.get_columns_info(self.db, tables)
         foreign_keys = await self.introspector.get_foreign_keys_info(self.db, tables)
         primary_keys = await self.introspector.get_primary_keys_info(self.db, tables)
+        indexes = await self.introspector.get_indexes_info(self.db, tables)
 
         # Build schema structure
         schema_info = self._build_table_structure(tables)
         self._add_columns_to_schema(schema_info, columns)
         self._add_primary_keys_to_schema(schema_info, primary_keys)
         self._add_foreign_keys_to_schema(schema_info, foreign_keys)
+        self._add_indexes_to_schema(schema_info, indexes)
 
         return schema_info
 
@@ -613,6 +739,7 @@ class SchemaManager:
                 "columns": {},
                 "primary_keys": [],
                 "foreign_keys": [],
+                "indexes": [],
             }
         return schema_info
 
@@ -666,6 +793,31 @@ class SchemaManager:
                     }
                 )
 
+    def _add_indexes_to_schema(
+        self, schema_info: dict[str, dict], indexes: list
+    ) -> None:
+        """Add index information to schema."""
+        for idx in indexes:
+            full_name = f"{idx['table_schema']}.{idx['table_name']}"
+            if full_name in schema_info:
+                # Handle different column name formats from different databases
+                if isinstance(idx["column_names"], list):
+                    columns = idx["column_names"]
+                else:
+                    # MySQL returns comma-separated string
+                    columns = (
+                        idx["column_names"].split(",") if idx["column_names"] else []
+                    )
+
+                schema_info[full_name]["indexes"].append(
+                    {
+                        "name": idx["index_name"],
+                        "columns": columns,
+                        "unique": idx["is_unique"],
+                        "type": idx.get("index_type"),
+                    }
+                )
+
     async def list_tables(self) -> dict[str, Any]:
         """Get a list of all tables with basic information."""
         tables = await self.introspector.list_tables_info(self.db)

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/src/sqlsaber/tools/sql_tools.py

@@ -138,6 +138,12 @@ class IntrospectSchemaTool(SQLTool):
                         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"]
+                    ],
                 }
 
             return json.dumps(formatted_info)

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/tests/test_tools/test_sql_tools.py

@@ -60,6 +60,7 @@ class MockSchemaManager:
                 },
                 "primary_keys": ["id"],
                 "foreign_keys": [],
+                "indexes": [],
             }
         }
         if table_pattern and table_pattern in schema:

{sqlsaber-0.22.0 → sqlsaber-0.24.0}/uv.lock

@@ -1910,7 +1910,7 @@ wheels = [
 
 [[package]]
 name = "sqlsaber"
-version = "0.22.0"
+version = "0.24.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiomysql" },