openduck-cli 0.1.0__py3-none-any.whl

openduck/gui/dialogs/__init__.py

@@ -0,0 +1,7 @@
+"""Modal dialogs for OpenDuck."""
+
+from openduck.gui.dialogs.add_connection_dialog import AddConnectionDialog
+from openduck.gui.dialogs.export_dialog import ExportDialog
+from openduck.gui.dialogs.save_query_dialog import SaveQueryDialog
+
+__all__ = ["SaveQueryDialog", "ExportDialog", "AddConnectionDialog"]

openduck/gui/dialogs/add_connection_dialog.py

@@ -0,0 +1,77 @@
+"""Modal dialog for adding database connections (MySQL / MSSQL)."""
+
+from datetime import datetime
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Select, Static
+
+
+class AddConnectionDialog(ModalScreen):
+    """Modal dialog to add a MySQL or MSSQL connection."""
+
+    def __init__(self, existing_conn: dict = None):
+        super().__init__()
+        self.existing_conn = existing_conn
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="conn-dialog"):
+            yield Static("Add Database Connection", id="conn-dialog-title")
+            yield Static("Type:")
+            yield Select(
+                [("MySQL", "mysql"), ("MSSQL", "mssql")],
+                prompt="Select type",
+                id="conn-type",
+                allow_blank=False,
+                value="mysql",
+            )
+            yield Input(placeholder="Display name...", id="conn-display-name")
+            yield Input(placeholder="Host (e.g. localhost)", id="conn-host", value="localhost")
+            yield Input(placeholder="Port", id="conn-port", value="3306")
+            yield Input(placeholder="Username", id="conn-user")
+            yield Input(placeholder="Password", id="conn-password", password=True)
+            yield Input(placeholder="Database name", id="conn-database")
+            with Horizontal():
+                yield Button("Connect", variant="primary", id="btn-connect")
+                yield Button("Cancel", id="btn-conn-cancel")
+            yield Static("", id="conn-status")
+
+    def on_mount(self):
+        self.query_one("#conn-display-name").focus()
+        if self.existing_conn:
+            self.query_one("#conn-type", Select).value = self.existing_conn["type"]
+            self.query_one("#conn-display-name", Input).value = self.existing_conn.get("display_name", "")
+            self.query_one("#conn-host", Input).value = self.existing_conn.get("host", "localhost")
+            self.query_one("#conn-port", Input).value = str(self.existing_conn.get("port", "3306"))
+            self.query_one("#conn-user", Input).value = self.existing_conn.get("user", "")
+            self.query_one("#conn-password", Input).value = self.existing_conn.get("password", "")
+            self.query_one("#conn-database", Input).value = self.existing_conn.get("database", "")
+
+    def on_select_changed(self, event: Select.Changed):
+        if event.select.id == "conn-type":
+            port_input = self.query_one("#conn-port", Input)
+            if event.value == "mysql" and port_input.value in ("1433", ""):
+                port_input.value = "3306"
+            elif event.value == "mssql" and port_input.value in ("3306", ""):
+                port_input.value = "1433"
+
+    def on_button_pressed(self, event: Button.Pressed):
+        if event.button.id == "btn-conn-cancel":
+            self.dismiss()
+        elif event.button.id == "btn-connect":
+            conn_info = {
+                "id": self.existing_conn["id"] if self.existing_conn else f"conn_{int(datetime.now().timestamp() * 1000)}",
+                "display_name": self.query_one("#conn-display-name", Input).value.strip(),
+                "type": self.query_one("#conn-type", Select).value,
+                "host": self.query_one("#conn-host", Input).value.strip(),
+                "port": int(self.query_one("#conn-port", Input).value.strip() or "0"),
+                "user": self.query_one("#conn-user", Input).value.strip(),
+                "password": self.query_one("#conn-password", Input).value,
+                "database": self.query_one("#conn-database", Input).value.strip(),
+            }
+            if not conn_info["display_name"]:
+                conn_info["display_name"] = f"{conn_info['type']}://{conn_info['host']}/{conn_info['database']}"
+            if not all([conn_info["host"], conn_info["database"]]):
+                self.query_one("#conn-status").update("[red]Host and database are required[/red]")
+                return
+            self.dismiss(conn_info)

openduck/gui/dialogs/export_dialog.py

@@ -0,0 +1,109 @@
+"""Modal dialog for exporting query results to CSV or Excel."""
+
+import asyncio
+import csv
+import logging
+import re
+from typing import TYPE_CHECKING, Tuple
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Static, TextArea
+
+from openduck.core.config import CWD
+
+if TYPE_CHECKING:
+    from openduck.gui.widgets.query_tab import QueryTab
+
+logger = logging.getLogger(__name__)
+
+
+class ExportDialog(ModalScreen):
+    """Modal dialog to export query results into CSV or XLSX files."""
+
+    def __init__(self, tab: 'QueryTab', export_type: str):
+        super().__init__()
+        self.tab = tab
+        self.export_type = export_type
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="export-modal"):
+            yield Static(f"Export {self.export_type.upper()}", id="export-modal-title")
+            yield Input(placeholder="Enter filename...", id="export-filename")
+            yield Static("Current query:", id="current-query-label")
+            yield Static(
+                self.tab.query_one(TextArea).text[:100]
+                + ("..." if len(self.tab.query_one(TextArea).text) > 100 else ""),
+                id="current-query-preview",
+            )
+            with Horizontal():
+                yield Button("Export", variant="primary", id="btn-export")
+                yield Button("Cancel", id="btn-cancel")
+
+    def on_mount(self):
+        # Pre-populate filename based on query content
+        query_text = self.tab.query_one(TextArea).text.strip()
+        table_match = re.search(r'FROM\s+(\w+)', query_text, re.IGNORECASE)
+        base_name = table_match.group(1) if table_match else "query_result"
+        base_name = re.sub(r'[^\w\-_]', '_', base_name)
+        extension = ".csv" if self.export_type == "csv" else ".xlsx"
+        default_filename = f"{base_name}{extension}"
+
+        self.query_one("#export-filename").value = default_filename
+        self.query_one("#export-filename").focus()
+
+    def export_to_csv(self, filename: str) -> Tuple[bool, str]:
+        """Export table data to CSV file."""
+        try:
+            filepath = CWD / filename
+            with open(filepath, 'w', newline='', encoding='utf-8') as csvfile:
+                writer = csv.writer(csvfile)
+                writer.writerow(self.tab.column_names)
+                for row in self.tab.full_data:
+                    writer.writerow(row)
+            return True, ""
+        except Exception as e:
+            logger.error(f"Failed to export CSV: {e}")
+            return False, str(e)
+
+    def export_to_excel(self, filename: str) -> Tuple[bool, str]:
+        """Export table data to Excel file."""
+        try:
+            import pandas as pd
+        except ImportError:
+            return False, "pandas is not installed (pip install pandas openpyxl)"
+        try:
+            import openpyxl  # noqa: F401
+        except ImportError:
+            return False, "openpyxl is not installed (pip install openpyxl)"
+        try:
+            filepath = CWD / filename
+            df = pd.DataFrame(self.tab.full_data, columns=self.tab.column_names)
+            df.to_excel(filepath, index=False)
+            return True, ""
+        except Exception as e:
+            logger.error(f"Failed to export Excel: {e}")
+            return False, str(e)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-cancel":
+            self.dismiss()
+        elif event.button.id == "btn-export":
+            filename = self.query_one("#export-filename", Input).value.strip()
+            if not filename:
+                self.query_one("#export-filename").value = ""
+                self.query_one("#export-filename").focus()
+                return
+
+            event.button.disabled = True
+            if self.export_type == "csv":
+                success, error_msg = await asyncio.to_thread(self.export_to_csv, filename)
+            else:
+                success, error_msg = await asyncio.to_thread(self.export_to_excel, filename)
+
+            event.button.disabled = False
+            if success:
+                self.app.notify(f"Geëxporteerd naar {filename}", timeout=2.0)
+                self.dismiss({"exported": True, "filename": filename})
+            else:
+                self.app.notify(f"Export mislukt: {error_msg}", severity="error", timeout=4.0)

openduck/gui/dialogs/save_query_dialog.py

@@ -0,0 +1,41 @@
+"""Modal dialog for saving named queries."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Static
+
+from openduck.core.config import save_query
+
+
+class SaveQueryDialog(ModalScreen):
+    """Modal dialog to save current query text with a custom name."""
+
+    def __init__(self, query_text: str):
+        super().__init__()
+        self.query_text = query_text
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="save-dialog"):
+            yield Static("Save Query", id="dialog-title")
+            yield Input(placeholder="Enter query name...", id="query-name")
+            yield Static("Query:", id="query-label")
+            yield Static(self.query_text[:100] + ("..." if len(self.query_text) > 100 else ""), id="query-preview")
+            with Horizontal():
+                yield Button("Save", variant="primary", id="btn-save")
+                yield Button("Cancel", id="btn-cancel")
+
+    def on_mount(self):
+        self.query_one("#query-name").focus()
+
+    def on_button_pressed(self, event: Button.Pressed):
+        if event.button.id == "btn-cancel":
+            self.dismiss()
+        elif event.button.id == "btn-save":
+            name = self.query_one("#query-name", Input).value
+            if name.strip():
+                save_query(name, self.query_text)
+                self.dismiss({"saved": True, "name": name})
+            else:
+                self.query_one("#query-name").value = ""
+                self.query_one("#query-name").focus()

openduck/gui/screens/__init__.py

@@ -0,0 +1,6 @@
+"""Modal screens for OpenDuck."""
+
+from openduck.gui.screens.about import AboutScreen, DUCK_ART, LOGO_RAW, lolcat
+from openduck.gui.screens.matrix import MatrixScreen
+
+__all__ = ["AboutScreen", "MatrixScreen", "DUCK_ART", "LOGO_RAW", "lolcat"]

openduck/gui/screens/about.py

@@ -0,0 +1,84 @@
+"""About OpenDuck modal dialog screen."""
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Middle, Vertical
+from textual.events import Click
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+from openduck.gui.screens.matrix import MatrixScreen
+from openduck.gui.styles import ABOUT_CSS
+
+LOGO_RAW = (
+    "   ___                       _            _    \n"
+    "  / _ \\ _ __   ___ _ __   __| |_   _  ___| | __\n"
+    " | | | | '_ \\ / _ \\ '_ \\ / _` | | | |/ __| |/ /\n"
+    " | |_| | |_) |  __/ | | | (_| | |_| | (__|   < \n"
+    "  \\___/| .__/ \\___|_| |_|\\__,_|\\__,_|\\___|_|\\_\\\n"
+    "       |_|                                     "
+)
+
+LOLCAT_COLORS = [
+    "#ff0000", "#ff4400", "#ff8800", "#ffcc00", "#ffff00", "#88ff00",
+    "#00ff00", "#00ff88", "#00ffff", "#0088ff", "#0000ff", "#4400ff",
+    "#8800ff", "#cc00ff", "#ff00ff", "#ff0088",
+]
+
+
+def lolcat(text: str) -> Text:
+    """Apply rainbow colors to text, Rich markup style."""
+    rich_text = Text(text)
+    lines = text.split("\n")
+    pos = 0
+    for row, line in enumerate(lines):
+        for col, ch in enumerate(line):
+            if ch != " ":
+                color = LOLCAT_COLORS[(col + row * 3) % len(LOLCAT_COLORS)]
+                rich_text.stylize(color, pos, pos + 1)
+            pos += 1
+        pos += 1  # newline
+    return rich_text
+
+
+DUCK_ART = r"""                  (o.                   H
+      _o)         |  . :             (o]H
+  \\\__/      \\\_|  : :.        \\\_\  H
+  <____).....<_____).:.::.......<_____).H"""
+
+
+class AboutScreen(ModalScreen):
+    """About dialog screen with ASCII duck and Easter egg link."""
+
+    DEFAULT_CSS = ABOUT_CSS
+
+    def compose(self) -> ComposeResult:
+        with Middle():
+            with Vertical(id="about-inner"):
+                yield Static(lolcat(LOGO_RAW), id="about-title")
+                yield Static("────────────────────────────────────────────────────")
+                yield Static("[b]GitHub:[/b] github.com/bertatron/duckcli")
+                yield Static("[b]Author:[/b] Bertatron")
+                yield Static("[b]License:[/b] MIT")
+                yield Static("\nKISS - Metadata & Async enabled.")
+                yield Static("Don't click here", id="easter-egg")
+                yield Static(DUCK_ART, id="duck-art")
+                yield Static("\n[Press any key to close]", id="about-footer")
+
+    def on_key(self) -> None:
+        self.dismiss()
+
+    def on_click(self, event: Click) -> None:
+        if hasattr(event, 'widget') and event.widget and event.widget.id == "easter-egg":
+            self.dismiss()
+            self.app.push_screen(MatrixScreen())
+        else:
+            try:
+                widget, _ = self.screen.get_widget_at(event.screen_x, event.screen_y)
+                if widget.id == "easter-egg":
+                    self.dismiss()
+                    self.app.push_screen(MatrixScreen())
+                    return
+            except Exception:
+                pass
+            self.dismiss()

openduck/gui/screens/matrix.py

@@ -0,0 +1,90 @@
+"""Matrix rain screensaver screen (Easter egg)."""
+
+import random
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+from openduck.gui.styles import MATRIX_CSS
+
+MATRIX_CHARS = "ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉ0123456789"
+# ANSI 256: 82=#87ff00, 46=#00ff00, 40=#00d700, 34=#00af00, 28=#008700, 22=#005f00
+MATRIX_SHADES = ["#87ff00", "#00ff00", "#00d700", "#00af00", "#008700", "#005f00"]
+
+
+class MatrixScreen(ModalScreen):
+    """Matrix code rain modal screensaver."""
+
+    DEFAULT_CSS = MATRIX_CSS
+
+    def __init__(self):
+        super().__init__()
+        self._drops = []
+        self._grid = []
+        self._colors = []
+        self._timer = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="matrix-canvas")
+
+    def on_mount(self) -> None:
+        cols = self.screen.size.width
+        rows = self.screen.size.height
+        self._drops = [random.randint(0, rows) for _ in range(cols)]
+        # Persistent grid - characters stay until overwritten
+        self._grid = [[" "] * cols for _ in range(rows)]
+        self._colors = [["#005f00"] * cols for _ in range(rows)]
+        self._timer = self.set_interval(0.03, self._tick)
+
+    def _tick(self) -> None:
+        cols = self.screen.size.width
+        rows = self.screen.size.height
+        # Resize grids if terminal changed
+        while len(self._drops) < cols:
+            self._drops.append(0)
+        self._drops = self._drops[:cols]
+        while len(self._grid) < rows:
+            self._grid.append([" "] * cols)
+            self._colors.append(["#005f00"] * cols)
+        self._grid = self._grid[:rows]
+        self._colors = self._colors[:rows]
+        for r in range(rows):
+            while len(self._grid[r]) < cols:
+                self._grid[r].append(" ")
+                self._colors[r].append("#005f00")
+            self._grid[r] = self._grid[r][:cols]
+            self._colors[r] = self._colors[r][:cols]
+        # Draw drops - characters persist on the grid like the original
+        for i in range(cols):
+            if random.random() > 0.97:
+                self._drops[i] = 0
+            for j, shade in enumerate(MATRIX_SHADES):
+                y = self._drops[i] - j
+                if 0 <= y < rows:
+                    self._grid[y][i] = random.choice(MATRIX_CHARS)
+                    self._colors[y][i] = shade
+            self._drops[i] += 1
+            if self._drops[i] >= rows:
+                self._drops[i] = 0
+        # Render
+        lines = []
+        for r in range(rows):
+            parts = []
+            for c in range(cols):
+                ch = self._grid[r][c]
+                if ch != " ":
+                    parts.append(f"[{self._colors[r][c]}]{ch}[/]")
+                else:
+                    parts.append(" ")
+            lines.append("".join(parts))
+        self.query_one("#matrix-canvas").update("\n".join(lines))
+
+    def on_key(self) -> None:
+        if self._timer:
+            self._timer.stop()
+        self.dismiss()
+
+    def on_click(self) -> None:
+        if self._timer:
+            self._timer.stop()
+        self.dismiss()

openduck/gui/styles.py

@@ -0,0 +1,71 @@
+"""Textual CSS styles for OpenDuck UI components."""
+
+APP_CSS = """
+#sidebar { width: 30; height: 100%; background: $surface; }
+#files { height: 2fr; min-height: 8; }
+#db-tree { height: 1fr; min-height: 8; }
+#db-tree-inner { height: 1fr; }
+#saved-queries-tree { height: 1fr; min-height: 5; }
+#history-tree { height: 1fr; min-height: 5; }
+#main-content { width: 1fr; }
+TabbedContent { width: 100%; height: 1fr; }
+SqlTextArea, TextArea { height: 35%; border-bottom: tall $primary; }
+ResultsTable, DataTable { height: 1fr; }
+#export-sidebar { width: 14; margin-left: 1; background: $panel; border: round $primary; padding: 0; overflow-y: auto; }
+.export-btn { margin: 0; padding: 0; height: 3; width: 100%; }
+#metadata-container {
+    height: 1;
+    background: $primary;
+    color: $text;
+    layout: horizontal;
+}
+#metadata-bar {
+    width: 1fr;
+    padding: 0 1;
+}
+#memory-bar {
+    width: auto;
+    padding: 0 1;
+    text-align: right;
+}
+#menu { padding: 1 2; background: $surface; border: tall $primary; width: 50; height: auto; }
+#menu-title { text-style: bold; margin-bottom: 1; }
+#filter-input { margin-bottom: 1; }
+Button { margin: 0 1; min-width: 10; }
+AboutScreen { align: center middle; background: rgba(0, 0, 0, 0.7); }
+#about-inner { width: 64; height: auto; background: $surface; border: tall $primary; padding: 2 4; }
+#about-title { text-align: center; color: $accent; }
+#about-footer { text-align: center; color: $text-disabled; }
+#save-dialog { width: 50; height: auto; background: $surface; border: tall $primary; padding: 2; }
+#dialog-title { text-style: bold; margin-bottom: 1; text-align: center; }
+#query-preview { height: 3; border: solid $primary; padding: 1; }
+#export-modal { width: 50; height: auto; background: $surface; border: tall $primary; padding: 2; }
+#export-modal-title { text-style: bold; margin-bottom: 1; text-align: center; }
+#export-filename { margin-bottom: 1; }
+#db-search-input { margin-bottom: 1; }
+#conn-dialog { width: 60; height: auto; background: $surface; border: tall $primary; padding: 2; }
+#conn-dialog-title { text-style: bold; margin-bottom: 1; text-align: center; }
+#conn-status { height: 1; margin-top: 1; }
+AddConnectionDialog { align: center middle; background: rgba(0, 0, 0, 0.7); }
+"""
+
+MATRIX_CSS = """
+MatrixScreen { background: black; }
+#matrix-canvas { width: 100%; height: 100%; background: black; }
+"""
+
+ABOUT_CSS = """
+#easter-egg { color: $text-disabled; }
+#duck-art { color: $accent; }
+"""
+
+RESIZE_CSS = """
+ResizeHandle {
+    width: 1;
+    height: 100%;
+    background: $primary;
+}
+ResizeHandle:hover {
+    background: $accent;
+}
+"""

openduck/gui/widgets/__init__.py

@@ -0,0 +1,17 @@
+"""UI widgets for OpenDuck."""
+
+from openduck.gui.widgets.database_tree import DatabaseTree
+from openduck.gui.widgets.file_tree import DuckTree
+from openduck.gui.widgets.query_tab import QueryTab
+from openduck.gui.widgets.resize_handle import ResizeHandle
+from openduck.gui.widgets.results_table import ResultsTable
+from openduck.gui.widgets.sql_editor import SqlTextArea
+
+__all__ = [
+    "DatabaseTree",
+    "DuckTree",
+    "QueryTab",
+    "ResizeHandle",
+    "ResultsTable",
+    "SqlTextArea",
+]

openduck/gui/widgets/database_tree.py

@@ -0,0 +1,106 @@
+"""Database connections explorer tree with table search."""
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Input, Tree
+
+
+class DatabaseTree(Vertical):
+    """Tree widget showing database connections and their tables with search functionality."""
+
+    def __init__(self):
+        super().__init__(id="db-tree")
+        self.connections_data = {}
+        self.original_tree = Tree("Databases", id="db-tree-inner")
+        self.search_input = Input(placeholder="Search tables...", id="db-search-input")
+
+    def compose(self) -> ComposeResult:
+        yield self.search_input
+        yield self.original_tree
+
+    def on_mount(self):
+        self.original_tree.root.expand()
+        self._ensure_add_node()
+
+    def _ensure_add_node(self):
+        """Make sure the '+ Add connection' node is always the last leaf."""
+        for child in list(self.original_tree.root.children):
+            if child.data and child.data.get("type") == "add_connection":
+                child.remove()
+        self.original_tree.root.add_leaf("+ Add connection", data={"type": "add_connection"})
+
+    def add_connection_node(self, conn_info: dict, tables: list = None):
+        conn_id = conn_info["id"]
+        type_icon = "\U0001f42c" if conn_info["type"] == "mysql" else "\U0001f537"
+        label = f"{type_icon} {conn_info['display_name']}"
+        self.remove_connection_node(conn_id)
+        # Store tables in connection info for table filtering
+        conn_info["tables"] = tables or []
+        self.connections_data[conn_id] = conn_info
+        conn_node = self.original_tree.root.add(
+            label,
+            data={"type": "connection", "conn_id": conn_id},
+            expand=True,
+        )
+        if tables:
+            for table_name in sorted(tables):
+                conn_node.add_leaf(
+                    f"  {table_name}",
+                    data={"type": "table", "conn_id": conn_id, "table": table_name, "database": conn_info["database"]},
+                )
+        else:
+            conn_node.add_leaf("Loading...", data={"type": "loading", "conn_id": conn_id})
+        self._ensure_add_node()
+
+    def remove_connection_node(self, conn_id: str):
+        for child in list(self.original_tree.root.children):
+            if child.data and child.data.get("conn_id") == conn_id:
+                child.remove()
+                break
+        self.connections_data.pop(conn_id, None)
+        self._ensure_add_node()
+
+    def filter_tables(self, search_term: str):
+        """Filter the tree to show only tables that match the search term."""
+        search_term = search_term.strip().lower()
+
+        # Clear the tree and rebuild with filtered content
+        self.original_tree.clear()
+
+        for conn_id, conn_info in self.connections_data.items():
+            type_icon = "\U0001f42c" if conn_info["type"] == "mysql" else "\U0001f537"
+            label = f"{type_icon} {conn_info['display_name']}"
+
+            all_tables = conn_info.get("tables", [])
+            if search_term:
+                filtered_tables = [table for table in all_tables if search_term in table.lower()]
+            else:
+                filtered_tables = all_tables
+
+            conn_node = self.original_tree.root.add(
+                label,
+                data={"type": "connection", "conn_id": conn_id},
+                expand=True,
+            )
+
+            if filtered_tables:
+                for table_name in sorted(filtered_tables):
+                    conn_node.add_leaf(
+                        f"  {table_name}",
+                        data={"type": "table", "conn_id": conn_id, "table": table_name, "database": conn_info["database"]},
+                    )
+            elif search_term:
+                conn_node.add_leaf(
+                    "  No matching tables",
+                    data={"type": "no_match", "conn_id": conn_id},
+                )
+            else:
+                conn_node.add_leaf("Loading...", data={"type": "loading", "conn_id": conn_id})
+
+        self._ensure_add_node()
+        self.original_tree.root.expand()
+
+    def update_tables(self, conn_id: str, tables: list):
+        conn_info = self.connections_data.get(conn_id)
+        if conn_info:
+            self.add_connection_node(conn_info, tables)

openduck/gui/widgets/file_tree.py

@@ -0,0 +1,14 @@
+"""Filtered directory tree for DuckDB-supported files."""
+
+from pathlib import Path
+from typing import Iterable
+from textual.widgets import DirectoryTree
+
+from openduck.core.sql_utils import is_duckdb_file
+
+
+class DuckTree(DirectoryTree):
+    """Directory tree that only shows directories and DuckDB-supported data files."""
+
+    def filter_paths(self, paths: Iterable[Path]) -> Iterable[Path]:
+        return [p for p in paths if p.is_dir() or is_duckdb_file(p)]