sqlsaber 0.23.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

sqlsaber/cli/display.py

@@ -198,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."""
@@ -225,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())
@@ -235,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)
 
@@ -248,9 +266,14 @@ 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."""
@@ -385,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/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)
@@ -135,6 +146,20 @@ def _render_transcript(
                             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(
@@ -143,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,
@@ -151,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))]:
@@ -270,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/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/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.23.0.dist-info → sqlsaber-0.24.0.dist-info}/METADATA

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

{sqlsaber-0.23.0.dist-info → sqlsaber-0.24.0.dist-info}/RECORD

@@ -9,12 +9,12 @@ sqlsaber/cli/auth.py,sha256=jTsRgbmlGPlASSuIKmdjjwfqtKvjfKd_cTYxX0-QqaQ,7400
 sqlsaber/cli/commands.py,sha256=mjLG9i1bXf0TEroxkIxq5O7Hhjufz3Ad72cyJz7vE1k,8128
 sqlsaber/cli/completers.py,sha256=HsUPjaZweLSeYCWkAcgMl8FylQ1xjWBWYTEL_9F6xfU,6430
 sqlsaber/cli/database.py,sha256=JKtHSN-BFzBa14REf0phFVQB7d67m1M5FFaD8N6DdrY,12966
-sqlsaber/cli/display.py,sha256=9uXg0GqFXGAwBj1O7-i6aLPQkGq-iURrsKHk6PWTq1E,15025
+sqlsaber/cli/display.py,sha256=XuKiTWUw5k0U0P_f1K7zhDWX5KTO2DQVG0Q0XU9VEhs,16334
 sqlsaber/cli/interactive.py,sha256=7uM4LoXbhPJr8o5yNjICSzL0uxZkp1psWrVq4G9V0OI,13118
 sqlsaber/cli/memory.py,sha256=OufHFJFwV0_GGn7LvKRTJikkWhV1IwNIUDOxFPHXOaQ,7794
 sqlsaber/cli/models.py,sha256=ZewtwGQwhd9b-yxBAPKePolvI1qQG-EkmeWAGMqtWNQ,8986
 sqlsaber/cli/streaming.py,sha256=Eo5CNUgDGY1WYP90jwDA2aY7RefN-TfcStA6NyjUQTY,7076
-sqlsaber/cli/threads.py,sha256=HJ6v9wEv1as21B7IJglYs3q6LH7Plv2oheLbM5YEQQA,11549
+sqlsaber/cli/threads.py,sha256=ufDABlqndVJKd5COgSokcFRIKTgsGqXdHV84DVVm7MA,12743
 sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
 sqlsaber/config/api_keys.py,sha256=RqWQCko1tY7sES7YOlexgBH5Hd5ne_kGXHdBDNqcV2U,3649
 sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
@@ -26,7 +26,7 @@ sqlsaber/config/settings.py,sha256=vgb_RXaM-7DgbxYDmWNw1cSyMqwys4j3qNCvM4bljwI,5
 sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
 sqlsaber/database/connection.py,sha256=1bDPEa6cmdh87gPfhNeBLpOdI0E2_2KlE74q_-4l_jI,18913
 sqlsaber/database/resolver.py,sha256=RPXF5EoKzvQDDLmPGNHYd2uG_oNICH8qvUjBp6iXmNY,3348
-sqlsaber/database/schema.py,sha256=r12qoN3tdtAXdO22EKlauAe7QwOm8lL2vTMM59XEMMY,26594
+sqlsaber/database/schema.py,sha256=Le5DXSgpsWyhMDuY6qpc_dsP4jjMXgJTRtAKq9S5Oog,32868
 sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
 sqlsaber/mcp/mcp.py,sha256=X12oCMZYAtgJ7MNuh5cqz8y3lALrOzkXWcfpuY0Ijxk,3950
 sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
@@ -39,9 +39,9 @@ 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=hM6tKqW5MDhFUt6MesoqhTUqIpq_5baIIDoN1MjDCXY,9647
-sqlsaber-0.23.0.dist-info/METADATA,sha256=olVI7W6UB-F6oZUqOjTWhJAvYtDbXXO0xoeOVYYmpfM,6178
-sqlsaber-0.23.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.23.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
-sqlsaber-0.23.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.23.0.dist-info/RECORD,,
+sqlsaber/tools/sql_tools.py,sha256=j4yRqfKokPFnZ_tEZPrWU5WStDc3Mexo1fWZ8KsmUjQ,9965
+sqlsaber-0.24.0.dist-info/METADATA,sha256=cPXj4eFPU-I6AWgHVVboKwu3zMmYKvs46LtrmZCBlhU,6178
+sqlsaber-0.24.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.24.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
+sqlsaber-0.24.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.24.0.dist-info/RECORD,,