sqlit-tui 1.2.7__tar.gz → 1.2.9__tar.gz

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlit-tui
-Version: 1.2.7
+Version: 1.2.9
 Summary: A terminal UI for SQL Server, PostgreSQL, MySQL, SQLite, Oracle, and more
 Project-URL: Homepage, https://github.com/Maxteabag/sqlit
 Project-URL: Repository, https://github.com/Maxteabag/sqlit

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.2.7'
-__version_tuple__ = version_tuple = (1, 2, 7)
+__version__ = version = '1.2.9'
+__version_tuple__ = version_tuple = (1, 2, 9)
 
 __commit_id__ = commit_id = None

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/core/keymap.py

@@ -11,6 +11,8 @@ KEY_DISPLAY_OVERRIDES: dict[str, str] = {
     "question_mark": "?",
     "slash": "/",
     "asterisk": "*",
+    "dollar_sign": "$",
+    "percent_sign": "%",
     "space": "<space>",
     "escape": "<esc>",
     "enter": "<enter>",
@@ -206,7 +208,7 @@ class DefaultKeymapProvider(KeymapProvider):
             LeaderCommandDef("e", "word_end", "Delete to word end", "Delete", menu="delete"),
             LeaderCommandDef("E", "WORD_end", "Delete to WORD end", "Delete", menu="delete"),
             LeaderCommandDef("0", "line_start", "Delete to line start", "Delete", menu="delete"),
-            LeaderCommandDef("$", "line_end_motion", "Delete to line end", "Delete", menu="delete"),
+            LeaderCommandDef("dollar_sign", "line_end_motion", "Delete to line end", "Delete", menu="delete"),
             LeaderCommandDef("D", "line_end", "Delete to line end", "Delete", menu="delete"),
             LeaderCommandDef("x", "char", "Delete char", "Delete", menu="delete"),
             LeaderCommandDef("X", "char_back", "Delete char back", "Delete", menu="delete"),
@@ -219,7 +221,7 @@ class DefaultKeymapProvider(KeymapProvider):
             LeaderCommandDef("F", "find_char_back", "Delete back to char...", "Delete", menu="delete"),
             LeaderCommandDef("t", "till_char", "Delete till char...", "Delete", menu="delete"),
             LeaderCommandDef("T", "till_char_back", "Delete back till char...", "Delete", menu="delete"),
-            LeaderCommandDef("%", "matching_bracket", "Delete to bracket", "Delete", menu="delete"),
+            LeaderCommandDef("percent_sign", "matching_bracket", "Delete to bracket", "Delete", menu="delete"),
             LeaderCommandDef("i", "inner", "Delete inside...", "Delete", menu="delete"),
             LeaderCommandDef("a", "around", "Delete around...", "Delete", menu="delete"),
             # Copy menu (vim-style, y for yank)
@@ -231,7 +233,7 @@ class DefaultKeymapProvider(KeymapProvider):
             LeaderCommandDef("e", "word_end", "Copy to word end", "Copy", menu="yank"),
             LeaderCommandDef("E", "WORD_end", "Copy to WORD end", "Copy", menu="yank"),
             LeaderCommandDef("0", "line_start", "Copy to line start", "Copy", menu="yank"),
-            LeaderCommandDef("$", "line_end_motion", "Copy to line end", "Copy", menu="yank"),
+            LeaderCommandDef("dollar_sign", "line_end_motion", "Copy to line end", "Copy", menu="yank"),
             LeaderCommandDef("h", "left", "Copy left", "Copy", menu="yank"),
             LeaderCommandDef("j", "down", "Copy line down", "Copy", menu="yank"),
             LeaderCommandDef("k", "up", "Copy line up", "Copy", menu="yank"),
@@ -241,7 +243,7 @@ class DefaultKeymapProvider(KeymapProvider):
             LeaderCommandDef("F", "find_char_back", "Copy back to char...", "Copy", menu="yank"),
             LeaderCommandDef("t", "till_char", "Copy till char...", "Copy", menu="yank"),
             LeaderCommandDef("T", "till_char_back", "Copy back till char...", "Copy", menu="yank"),
-            LeaderCommandDef("%", "matching_bracket", "Copy to bracket", "Copy", menu="yank"),
+            LeaderCommandDef("percent_sign", "matching_bracket", "Copy to bracket", "Copy", menu="yank"),
             LeaderCommandDef("i", "inner", "Copy inside...", "Copy", menu="yank"),
             LeaderCommandDef("a", "around", "Copy around...", "Copy", menu="yank"),
             # Change menu (vim-style)
@@ -253,7 +255,7 @@ class DefaultKeymapProvider(KeymapProvider):
             LeaderCommandDef("e", "word_end", "Change to word end", "Change", menu="change"),
             LeaderCommandDef("E", "WORD_end", "Change to WORD end", "Change", menu="change"),
             LeaderCommandDef("0", "line_start", "Change to line start", "Change", menu="change"),
-            LeaderCommandDef("$", "line_end_motion", "Change to line end", "Change", menu="change"),
+            LeaderCommandDef("dollar_sign", "line_end_motion", "Change to line end", "Change", menu="change"),
             LeaderCommandDef("h", "left", "Change left", "Change", menu="change"),
             LeaderCommandDef("j", "down", "Change line down", "Change", menu="change"),
             LeaderCommandDef("k", "up", "Change line up", "Change", menu="change"),
@@ -263,7 +265,7 @@ class DefaultKeymapProvider(KeymapProvider):
             LeaderCommandDef("F", "find_char_back", "Change back to char...", "Change", menu="change"),
             LeaderCommandDef("t", "till_char", "Change till char...", "Change", menu="change"),
             LeaderCommandDef("T", "till_char_back", "Change back till char...", "Change", menu="change"),
-            LeaderCommandDef("%", "matching_bracket", "Change to bracket", "Change", menu="change"),
+            LeaderCommandDef("percent_sign", "matching_bracket", "Change to bracket", "Change", menu="change"),
             LeaderCommandDef("i", "inner", "Change inside...", "Change", menu="change"),
             LeaderCommandDef("a", "around", "Change around...", "Change", menu="change"),
             # g motion menu (vim-style)
@@ -325,10 +327,6 @@ class DefaultKeymapProvider(KeymapProvider):
             ActionKeyDef("ctrl+q", "quit", "global"),
             ActionKeyDef("escape", "cancel_operation", "global"),
             ActionKeyDef("question_mark", "show_help", "global"),
-            # Navigation
-            ActionKeyDef("e", "focus_explorer", "navigation"),
-            ActionKeyDef("q", "focus_query", "navigation"),
-            ActionKeyDef("r", "focus_results", "navigation"),
             # Query (normal mode)
             ActionKeyDef("i", "enter_insert_mode", "query_normal"),
             ActionKeyDef("o", "open_line_below", "query_normal"),
@@ -348,10 +346,30 @@ class DefaultKeymapProvider(KeymapProvider):
             ActionKeyDef("j", "cursor_down", "query_normal"),
             ActionKeyDef("k", "cursor_up", "query_normal"),
             ActionKeyDef("l", "cursor_right", "query_normal"),
+            ActionKeyDef("w", "cursor_word_forward", "query_normal"),
+            ActionKeyDef("W", "cursor_WORD_forward", "query_normal"),
+            ActionKeyDef("b", "cursor_word_back", "query_normal"),
+            ActionKeyDef("B", "cursor_WORD_back", "query_normal"),
+            ActionKeyDef("e", "cursor_word_end", "query_normal"),
+            ActionKeyDef("E", "cursor_WORD_end", "query_normal"),
+            ActionKeyDef("0", "cursor_line_start", "query_normal"),
+            ActionKeyDef("dollar_sign", "cursor_line_end", "query_normal"),
+            ActionKeyDef("G", "cursor_last_line", "query_normal"),
+            ActionKeyDef("percent_sign", "cursor_matching_bracket", "query_normal"),
+            ActionKeyDef("f", "cursor_find_char", "query_normal"),
+            ActionKeyDef("F", "cursor_find_char_back", "query_normal"),
+            ActionKeyDef("t", "cursor_till_char", "query_normal"),
+            ActionKeyDef("T", "cursor_till_char_back", "query_normal"),
+            ActionKeyDef("a", "append_insert_mode", "query_normal"),
+            ActionKeyDef("A", "append_line_end", "query_normal"),
             # Query (insert mode)
             ActionKeyDef("escape", "exit_insert_mode", "query_insert"),
             ActionKeyDef("ctrl+enter", "execute_query_insert", "query_insert"),
             ActionKeyDef("tab", "autocomplete_accept", "query_insert"),
+            # Navigation
+            ActionKeyDef("e", "focus_explorer", "navigation"),
+            ActionKeyDef("q", "focus_query", "navigation"),
+            ActionKeyDef("r", "focus_results", "navigation"),
             # Query (autocomplete)
             ActionKeyDef("ctrl+j", "autocomplete_next", "autocomplete"),
             ActionKeyDef("ctrl+k", "autocomplete_prev", "autocomplete"),

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/domains/connections/providers/adapters/base.py

@@ -194,6 +194,11 @@ class DatabaseAdapter(ABC):
         """
         return False
 
+    @property
+    def supports_process_worker(self) -> bool:
+        """Whether this adapter supports running queries in a separate process."""
+        return True
+
     @property
     def test_query(self) -> str:
         """A simple query to test the connection.

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/domains/connections/providers/duckdb/adapter.py

@@ -55,6 +55,11 @@ class DuckDBAdapter(DatabaseAdapter):
         """DuckDB supports sequences."""
         return True
 
+    @property
+    def supports_process_worker(self) -> bool:
+        """DuckDB file locking conflicts with multi-process connections."""
+        return False
+
     @property
     def default_schema(self) -> str:
         return "main"

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/domains/explorer/ui/tree/loaders.py

@@ -66,6 +66,14 @@ def load_columns_async(host: TreeMixinHost, node: Any, data: TableNode | ViewNod
             use_worker = bool(getattr(runtime, "process_worker", False)) and not bool(
                 getattr(getattr(runtime, "mock", None), "enabled", False)
             )
+            if use_worker:
+                try:
+                    from sqlit.domains.process_worker.app.support import supports_process_worker
+                except Exception:
+                    pass
+                else:
+                    provider = getattr(host, "current_provider", None)
+                    use_worker = supports_process_worker(provider)
             if use_worker and hasattr(host, "_get_process_worker_client_async"):
                 client = await host._get_process_worker_client_async()  # type: ignore[attr-defined]
             else:
@@ -159,6 +167,14 @@ def load_folder_async(host: TreeMixinHost, node: Any, data: FolderNode) -> None:
             use_worker = bool(getattr(runtime, "process_worker", False)) and not bool(
                 getattr(getattr(runtime, "mock", None), "enabled", False)
             )
+            if use_worker:
+                try:
+                    from sqlit.domains.process_worker.app.support import supports_process_worker
+                except Exception:
+                    pass
+                else:
+                    provider = getattr(host, "current_provider", None)
+                    use_worker = supports_process_worker(provider)
             client = None
             if use_worker and hasattr(host, "_get_process_worker_client_async"):
                 client = await host._get_process_worker_client_async()  # type: ignore[attr-defined]

sqlit_tui-1.2.9/sqlit/domains/process_worker/app/support.py

@@ -0,0 +1,15 @@
+"""Helpers for deciding process worker availability."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def supports_process_worker(provider: Any) -> bool:
+    """Return False when a provider or adapter opts out of process workers."""
+    adapter = getattr(provider, "connection_factory", None)
+    for candidate in (adapter, provider):
+        value = getattr(candidate, "supports_process_worker", None)
+        if isinstance(value, bool):
+            return value
+    return True

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/domains/process_worker/ui/mixins/process_worker_lifecycle.py

@@ -22,7 +22,11 @@ class ProcessWorkerLifecycleMixin(LifecycleHooksMixin):
             return False
         if bool(getattr(getattr(runtime, "mock", None), "enabled", False)):
             return False
-        return True
+        try:
+            from sqlit.domains.process_worker.app.support import supports_process_worker
+        except Exception:
+            return True
+        return supports_process_worker(provider)
 
     def _get_process_worker_client(self: QueryMixinHost) -> Any | None:
         client = getattr(self, "_process_worker_client", None)

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/domains/query/state/query_normal.py

@@ -26,6 +26,22 @@ class QueryNormalModeState(State):
         self.allows("cursor_right", help="Move cursor right")
         self.allows("cursor_up", help="Move cursor up")
         self.allows("cursor_down", help="Move cursor down")
+        self.allows("cursor_word_forward", help="Move to next word")
+        self.allows("cursor_WORD_forward", help="Move to next WORD")
+        self.allows("cursor_word_back", help="Move to previous word")
+        self.allows("cursor_WORD_back", help="Move to previous WORD")
+        self.allows("cursor_word_end", help="Move to end of word")
+        self.allows("cursor_WORD_end", help="Move to end of WORD")
+        self.allows("cursor_line_start", help="Move to line start")
+        self.allows("cursor_line_end", help="Move to line end")
+        self.allows("cursor_last_line", help="Move to last line")
+        self.allows("cursor_matching_bracket", help="Move to matching bracket")
+        self.allows("cursor_find_char", help="Find char forward")
+        self.allows("cursor_find_char_back", help="Find char backward")
+        self.allows("cursor_till_char", help="Move till char forward")
+        self.allows("cursor_till_char_back", help="Move till char backward")
+        self.allows("append_insert_mode", help="Append after cursor")
+        self.allows("append_line_end", help="Append at line end")
         # Vim open line
         self.allows("open_line_below", help="Open line below")
         self.allows("open_line_above", help="Open line above")

sqlit_tui-1.2.9/sqlit/domains/query/ui/mixins/query_editing_cursor.py

@@ -0,0 +1,179 @@
+"""Cursor and navigation actions for query editing."""
+
+from __future__ import annotations
+
+from sqlit.shared.ui.protocols import QueryMixinHost
+
+
+class QueryEditingCursorMixin:
+    """Cursor movement and navigation for the query editor."""
+
+    def _move_with_motion(self: QueryMixinHost, motion_key: str, char: str | None = None) -> None:
+        """Move cursor using a vim motion."""
+        from sqlit.domains.query.editing import MOTIONS
+
+        motion_func = MOTIONS.get(motion_key)
+        if not motion_func:
+            return
+
+        text = self.query_input.text
+        row, col = self.query_input.cursor_location
+        result = motion_func(text, row, col, char)
+        self.query_input.cursor_location = (result.position.row, result.position.col)
+
+    def action_g_leader_key(self: QueryMixinHost) -> None:
+        """Show the g motion leader menu."""
+        self._start_leader_pending("g")
+
+    def action_g_first_line(self: QueryMixinHost) -> None:
+        """Go to first line (gg)."""
+        self._clear_leader_pending()
+        self.query_input.cursor_location = (0, 0)
+
+    def action_g_word_end_back(self: QueryMixinHost) -> None:
+        """Go to end of previous word (ge)."""
+        self._clear_leader_pending()
+        self._move_with_motion("ge")
+
+    def action_g_WORD_end_back(self: QueryMixinHost) -> None:
+        """Go to end of previous WORD (gE)."""
+        self._clear_leader_pending()
+        self._move_with_motion("gE")
+
+    def action_cursor_left(self: QueryMixinHost) -> None:
+        """Move cursor left (h in normal mode)."""
+        row, col = self.query_input.cursor_location
+        self.query_input.cursor_location = (row, max(0, col - 1))
+
+    def action_cursor_right(self: QueryMixinHost) -> None:
+        """Move cursor right (l in normal mode)."""
+        lines = self.query_input.text.split("\n")
+        row, col = self.query_input.cursor_location
+        line_len = len(lines[row]) if row < len(lines) else 0
+        self.query_input.cursor_location = (row, min(col + 1, line_len))
+
+    def action_cursor_up(self: QueryMixinHost) -> None:
+        """Move cursor up (k in normal mode)."""
+        lines = self.query_input.text.split("\n")
+        row, col = self.query_input.cursor_location
+        new_row = max(0, row - 1)
+        new_col = min(col, len(lines[new_row]) if new_row < len(lines) else 0)
+        self.query_input.cursor_location = (new_row, new_col)
+
+    def action_cursor_down(self: QueryMixinHost) -> None:
+        """Move cursor down (j in normal mode)."""
+        lines = self.query_input.text.split("\n")
+        row, col = self.query_input.cursor_location
+        new_row = min(row + 1, len(lines) - 1)
+        new_col = min(col, len(lines[new_row]) if new_row < len(lines) else 0)
+        self.query_input.cursor_location = (new_row, new_col)
+
+    def action_cursor_word_forward(self: QueryMixinHost) -> None:
+        """Move cursor to next word (w)."""
+        self._move_with_motion("w")
+
+    def action_cursor_WORD_forward(self: QueryMixinHost) -> None:
+        """Move cursor to next WORD (W)."""
+        self._move_with_motion("W")
+
+    def action_cursor_word_back(self: QueryMixinHost) -> None:
+        """Move cursor to previous word (b)."""
+        self._move_with_motion("b")
+
+    def action_cursor_WORD_back(self: QueryMixinHost) -> None:
+        """Move cursor to previous WORD (B)."""
+        self._move_with_motion("B")
+
+    def action_cursor_word_end(self: QueryMixinHost) -> None:
+        """Move cursor to end of word (e)."""
+        self._move_with_motion("e")
+
+    def action_cursor_WORD_end(self: QueryMixinHost) -> None:
+        """Move cursor to end of WORD (E)."""
+        self._move_with_motion("E")
+
+    def action_cursor_line_start(self: QueryMixinHost) -> None:
+        """Move cursor to start of line (0)."""
+        self._move_with_motion("0")
+
+    def action_cursor_line_end(self: QueryMixinHost) -> None:
+        """Move cursor to end of line ($)."""
+        self._move_with_motion("$")
+
+    def action_cursor_last_line(self: QueryMixinHost) -> None:
+        """Move cursor to last line (G)."""
+        self._move_with_motion("G")
+
+    def action_cursor_matching_bracket(self: QueryMixinHost) -> None:
+        """Move cursor to matching bracket (%)."""
+        self._move_with_motion("%")
+
+    def action_cursor_find_char(self: QueryMixinHost) -> None:
+        """Find next occurrence of char (f{c})."""
+        self._show_motion_char_pending_menu("f")
+
+    def action_cursor_find_char_back(self: QueryMixinHost) -> None:
+        """Find previous occurrence of char (F{c})."""
+        self._show_motion_char_pending_menu("F")
+
+    def action_cursor_till_char(self: QueryMixinHost) -> None:
+        """Move till before next char (t{c})."""
+        self._show_motion_char_pending_menu("t")
+
+    def action_cursor_till_char_back(self: QueryMixinHost) -> None:
+        """Move till after previous char (T{c})."""
+        self._show_motion_char_pending_menu("T")
+
+    def action_append_insert_mode(self: QueryMixinHost) -> None:
+        """Enter insert mode after cursor (a)."""
+        lines = self.query_input.text.split("\n")
+        row, col = self.query_input.cursor_location
+        line_len = len(lines[row]) if row < len(lines) else 0
+        self.query_input.cursor_location = (row, min(col + 1, line_len))
+        self.action_enter_insert_mode()
+
+    def action_append_line_end(self: QueryMixinHost) -> None:
+        """Enter insert mode at end of line (A)."""
+        lines = self.query_input.text.split("\n")
+        row, _ = self.query_input.cursor_location
+        line_len = len(lines[row]) if row < len(lines) else 0
+        self.query_input.cursor_location = (row, line_len)
+        self.action_enter_insert_mode()
+
+    def _show_motion_char_pending_menu(self: QueryMixinHost, motion: str) -> None:
+        """Show char pending menu for f/F/t/T motions (cursor movement)."""
+        from sqlit.domains.query.ui.screens import CharPendingMenuScreen
+
+        def handle_result(char: str | None) -> None:
+            if char:
+                self._move_with_motion(motion, char)
+
+        self.push_screen(CharPendingMenuScreen(motion), handle_result)
+
+    def action_open_line_below(self: QueryMixinHost) -> None:
+        """Open new line below current line and enter insert mode (o in normal mode)."""
+        self._push_undo_state()
+        lines = self.query_input.text.split("\n")
+        row, _ = self.query_input.cursor_location
+
+        # Insert new line after current row
+        lines.insert(row + 1, "")
+        self.query_input.text = "\n".join(lines)
+        self.query_input.cursor_location = (row + 1, 0)
+
+        # Enter insert mode
+        self.action_enter_insert_mode()
+
+    def action_open_line_above(self: QueryMixinHost) -> None:
+        """Open new line above current line and enter insert mode (O in normal mode)."""
+        self._push_undo_state()
+        lines = self.query_input.text.split("\n")
+        row, _ = self.query_input.cursor_location
+
+        # Insert new line before current row
+        lines.insert(row, "")
+        self.query_input.text = "\n".join(lines)
+        self.query_input.cursor_location = (row, 0)
+
+        # Enter insert mode
+        self.action_enter_insert_mode()

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/sqlit/domains/shell/app/main.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import os
+import platform
+import subprocess
 import sys
 import time
 from datetime import datetime
@@ -552,6 +554,10 @@ class SSMSTUI(
             self._show_command_list()
             return
 
+        if cmd in {"version", "ver"}:
+            self._show_version_info()
+            return
+
         if cmd in {"q", "quit", "exit"}:
             try:
                 handler = getattr(self, "action_quit", None)
@@ -648,6 +654,7 @@ class SSMSTUI(
         columns = ["Title", "Command", "Description", "Hint"]
         rows = [
             ("General", ":commands", "Show this command list", ""),
+            ("General", ":version, :ver", "Show version and git hash", ""),
             ("General", ":help, :h", "Show keyboard shortcuts", ""),
             ("General", ":q, :quit, :exit", "Quit sqlit", ""),
             ("Connection", ":connect, :c", "Open connection picker", ""),
@@ -697,6 +704,89 @@ class SSMSTUI(
         if hasattr(self, "_replace_results_table"):
             self._replace_results_table(columns, rows)
 
+    def _resolve_repo_root(self) -> Path | None:
+        path = Path(__file__).resolve()
+        for parent in (path, *path.parents):
+            if (parent / ".git").exists():
+                return parent
+        return None
+
+    def _parse_git_hash_from_version(self, version: str) -> str | None:
+        import re
+
+        match = re.search(r"\\+g([0-9a-fA-F]{7,})", version)
+        if not match:
+            return None
+        return match.group(1)
+
+    def _get_git_info(self) -> tuple[str | None, bool | None]:
+        repo_root = self._resolve_repo_root()
+        if repo_root is None:
+            return None, None
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--short", "HEAD"],
+                cwd=repo_root,
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            git_hash = result.stdout.strip() or None
+        except Exception:
+            git_hash = None
+        dirty: bool | None = None
+        try:
+            status = subprocess.run(
+                ["git", "status", "--porcelain"],
+                cwd=repo_root,
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            if status.stdout is not None:
+                dirty = bool(status.stdout.strip())
+        except Exception:
+            dirty = None
+        return git_hash, dirty
+
+    def _show_version_info(self) -> None:
+        try:
+            from sqlit import __version__ as pkg_version
+        except Exception:
+            pkg_version = "unknown"
+
+        git_hash = self._parse_git_hash_from_version(pkg_version)
+        dirty: bool | None = None
+        if git_hash is None:
+            git_hash, dirty = self._get_git_info()
+        else:
+            _repo_hash, dirty = self._get_git_info()
+
+        git_display = git_hash or "unknown"
+        dirty_display = "unknown"
+        if dirty is True:
+            dirty_display = "yes"
+            if git_hash:
+                git_display = f"{git_display} (dirty)"
+        elif dirty is False:
+            dirty_display = "no"
+
+        info_rows = [
+            ("version", pkg_version),
+            ("git", git_display),
+            ("dirty", dirty_display),
+            ("python", platform.python_version()),
+            ("platform", sys.platform),
+        ]
+
+        if hasattr(self, "_replace_results_table"):
+            self._replace_results_table(["Key", "Value"], info_rows)
+
+        summary = f"sqlit {pkg_version}"
+        if git_hash:
+            summary = f"{summary} ({git_hash})"
+        self.notify(summary, severity="information")
+
     def _execute_command_action(self, action: str) -> None:
         ctx = self._get_input_context()
         if not self._state_machine.check_action(ctx, action):

{sqlit_tui-1.2.7 → sqlit_tui-1.2.9}/tests/test_duckdb.py

@@ -2,6 +2,11 @@
 
 from __future__ import annotations
 
+import sys
+from pathlib import Path
+
+import pytest
+
 from .test_database_base import BaseDatabaseTestsWithLimit, DatabaseTestConfig
 
 
@@ -128,3 +133,86 @@ class TestDuckDBIntegration(BaseDatabaseTestsWithLimit):
         )
         # Should fail gracefully
         assert result.returncode != 0 or "error" in result.stdout.lower() or "error" in result.stderr.lower()
+
+
+@pytest.mark.parametrize("use_worker", [True, False])
+def test_duckdb_process_worker_no_lock(duckdb_db, use_worker):
+    """Ensure DuckDB queries work with or without the process worker."""
+    if sys.platform.startswith("win"):
+        pytest.skip("DuckDB file-lock behavior differs on Windows")
+
+    from sqlit.domains.connections.app.session import ConnectionSession
+    from sqlit.domains.connections.domain.config import ConnectionConfig, FileEndpoint
+    from sqlit.domains.process_worker.app.process_worker_client import ProcessWorkerClient
+    from sqlit.domains.process_worker.app.support import supports_process_worker
+    from sqlit.domains.query.app.transaction import TransactionExecutor
+
+    config = ConnectionConfig(
+        name="duckdb_lock_test",
+        db_type="duckdb",
+        endpoint=FileEndpoint(path=str(duckdb_db)),
+    )
+
+    session = ConnectionSession.create(config)
+    try:
+        outcome = None
+        use_worker_effective = bool(use_worker and supports_process_worker(session.provider))
+        if use_worker_effective:
+            client = ProcessWorkerClient()
+            try:
+                outcome = client.execute("SELECT 1", config, max_rows=1)
+            finally:
+                client.close()
+        else:
+            executor = TransactionExecutor(config=config, provider=session.provider)
+            try:
+                executor.execute("SELECT 1", max_rows=1)
+            finally:
+                executor.close()
+    finally:
+        session.close()
+
+    if use_worker_effective:
+        assert outcome is not None
+        assert outcome.error is None, f"Unexpected error: {outcome.error}"
+
+
+def test_duckdb_schema_service_repo_file(tmp_path):
+    """Validate explorer schema service against the repo DuckDB fixture."""
+    if sys.platform.startswith("win"):
+        pytest.skip("DuckDB file-lock behavior differs on Windows")
+
+    from sqlit.domains.connections.app.session import ConnectionSession
+    from sqlit.domains.connections.domain.config import ConnectionConfig, FileEndpoint
+    from sqlit.domains.explorer.app.schema_service import ExplorerSchemaService
+    try:
+        import duckdb  # type: ignore
+    except Exception:
+        pytest.skip("duckdb is not installed")
+
+    db_path = Path(tmp_path) / "cats.duckdb"
+    conn = duckdb.connect(str(db_path))
+    conn.execute("CREATE TABLE cats (id INTEGER, name VARCHAR, motto VARCHAR)")
+    conn.execute("INSERT INTO cats VALUES (1, 'Mochi', 'Nap hard, snack harder')")
+    conn.execute("INSERT INTO cats VALUES (2, 'Nimbus', 'Gravity is optional')")
+    conn.close()
+
+    config = ConnectionConfig(
+        name="duckdb_repo_fixture",
+        db_type="duckdb",
+        endpoint=FileEndpoint(path=str(db_path)),
+    )
+
+    session = ConnectionSession.create(config)
+    try:
+        service = ExplorerSchemaService(session=session, object_cache={})
+        tables = service.list_folder_items("tables", None)
+        table_names = {name for kind, _, name in tables if kind == "table"}
+        assert "cats" in table_names
+
+        schema = session.provider.capabilities.default_schema or "main"
+        columns = service.list_columns(None, schema, "cats")
+        column_names = {col.name for col in columns}
+        assert {"id", "name", "motto"}.issubset(column_names)
+    finally:
+        session.close()