Hyperoptimization (#64)

* Hyperoptimizied

* Uhh getting somewhere

* Nice optimiations

* Fix werid little thing

* Fix

* Telescope

* Reactive connection map

* Nice telescope

* sqlit is the best now

* Betterhelp

* Better advice

* Meh

* Debug logging

* Fix bug!

* Fix telescope hangup bug

* Nice telescope

* Indexing is now off thread

* Cleanups

* Optional postgres host

* Not execute queries automatically from telescope

* Safer scheduler

---------

Co-authored-by: Peter Adams <18162810+Maxteabag@users.noreply.github.com>

Author: Maxteabag

config/settings.template.json

@@ -3,6 +3,10 @@
   "theme": "tokyo-night",
   "custom_themes": [],
   "expanded_nodes": [],
+  "process_worker": true,
+  "process_worker_warm_on_idle": true,
+  "process_worker_auto_shutdown_s": 0,
+  "ui_stall_watchdog_ms": 0,
   "allow_plaintext_credentials": false,
   "mock": {
     "enabled": true,

sqlit/core/keymap.py

@@ -5,6 +5,8 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
+from sqlit.shared.core.debug_events import emit_debug_event
+
 KEY_DISPLAY_OVERRIDES: dict[str, str] = {
     "question_mark": "?",
     "slash": "/",
@@ -118,7 +120,68 @@ def actions_for_key(self, key: str) -> list[str]:
 class DefaultKeymapProvider(KeymapProvider):
     """Default keymap with hardcoded bindings."""
 
+    def __init__(self) -> None:
+        self._leader_commands_cache: list[LeaderCommandDef] | None = None
+        self._action_keys_cache: list[ActionKeyDef] | None = None
+        self._leader_emitted: bool = False
+        self._action_emitted: bool = False
+
+    def _emit_leader_keybindings(self, commands: list[LeaderCommandDef]) -> None:
+        for cmd in commands:
+            emit_debug_event(
+                "keybinding.register",
+                category="keybinding",
+                kind="leader",
+                provider=self.__class__.__name__,
+                key=cmd.key,
+                action=cmd.action,
+                label=cmd.label,
+                group=cmd.category,
+                menu=cmd.menu,
+                guard=cmd.guard,
+            )
+
+    def _emit_action_keybindings(self, bindings: list[ActionKeyDef]) -> None:
+        for binding in bindings:
+            emit_debug_event(
+                "keybinding.register",
+                category="keybinding",
+                kind="action",
+                provider=self.__class__.__name__,
+                key=binding.key,
+                action=binding.action,
+                context=binding.context,
+                guard=binding.guard,
+                primary=binding.primary,
+                show=binding.show,
+                priority=binding.priority,
+            )
+
+    def _ensure_leader_commands(self) -> list[LeaderCommandDef]:
+        if self._leader_commands_cache is None:
+            self._leader_commands_cache = self._build_leader_commands()
+        return self._leader_commands_cache
+
+    def _ensure_action_keys(self) -> list[ActionKeyDef]:
+        if self._action_keys_cache is None:
+            self._action_keys_cache = self._build_action_keys()
+        return self._action_keys_cache
+
     def get_leader_commands(self) -> list[LeaderCommandDef]:
+        commands = self._ensure_leader_commands()
+        if not self._leader_emitted:
+            self._emit_leader_keybindings(commands)
+            self._leader_emitted = True
+        return list(commands)
+
+    def get_action_keys(self) -> list[ActionKeyDef]:
+        bindings = self._ensure_action_keys()
+        if not self._action_emitted:
+            self._emit_action_keybindings(bindings)
+            self._action_emitted = True
+        return list(bindings)
+
+    def _build_leader_commands(self) -> list[LeaderCommandDef]:
         return [
             # View
             LeaderCommandDef("e", "toggle_explorer", "Toggle Explorer", "View"),
@@ -130,6 +193,8 @@ def get_leader_commands(self) -> list[LeaderCommandDef]:
             LeaderCommandDef("z", "cancel_operation", "Cancel", "Actions", guard="query_executing"),
             LeaderCommandDef("t", "change_theme", "Change Theme", "Actions"),
             LeaderCommandDef("h", "show_help", "Help", "Actions"),
+            LeaderCommandDef("space", "telescope", "Telescope", "Actions"),
+            LeaderCommandDef("slash", "telescope_filter", "Telescope Search", "Actions"),
             LeaderCommandDef("q", "quit", "Quit", "Actions"),
             # Delete menu (vim-style)
             LeaderCommandDef("d", "line", "Delete line", "Delete", menu="delete"),
@@ -222,7 +287,7 @@ def get_leader_commands(self) -> list[LeaderCommandDef]:
             LeaderCommandDef("j", "json", "Export as JSON", "Export", menu="rye"),
         ]
 
-    def get_action_keys(self) -> list[ActionKeyDef]:
+    def _build_action_keys(self) -> list[ActionKeyDef]:
         return [
             # Tree actions
             ActionKeyDef("n", "new_connection", "tree"),
@@ -243,6 +308,7 @@ def get_action_keys(self) -> list[ActionKeyDef]:
             # Global
             ActionKeyDef("space", "leader_key", "global", priority=True),
             ActionKeyDef("ctrl+q", "quit", "global"),
+            ActionKeyDef("escape", "cancel_operation", "global"),
             ActionKeyDef("question_mark", "show_help", "global"),
             # Navigation
             ActionKeyDef("e", "focus_explorer", "navigation"),
@@ -322,9 +388,62 @@ def set_keymap(provider: KeymapProvider) -> None:
     """Set the keymap provider (for testing or custom keymaps)."""
     global _keymap_provider
     _keymap_provider = provider
+    emit_keybinding_snapshot(provider)
 
 
 def reset_keymap() -> None:
     """Reset to default keymap provider."""
     global _keymap_provider
     _keymap_provider = None
+
+
+def emit_keybinding_snapshot(provider: KeymapProvider | None = None) -> None:
+    """Emit debug events for the current keymap bindings."""
+    keymap = provider or get_keymap()
+    if hasattr(keymap, "_ensure_leader_commands"):
+        commands = keymap._ensure_leader_commands()  # type: ignore[attr-defined]
+    else:
+        commands = keymap.get_leader_commands()
+    for cmd in commands:
+        emit_debug_event(
+            "keybinding.register",
+            category="keybinding",
+            source="snapshot",
+            kind="leader",
+            provider=keymap.__class__.__name__,
+            key=cmd.key,
+            action=cmd.action,
+            label=cmd.label,
+            group=cmd.category,
+            menu=cmd.menu,
+            guard=cmd.guard,
+        )
+    if hasattr(keymap, "_leader_emitted"):
+        try:
+            keymap._leader_emitted = True  # type: ignore[attr-defined]
+        except Exception:
+            pass
+    if hasattr(keymap, "_ensure_action_keys"):
+        bindings = keymap._ensure_action_keys()  # type: ignore[attr-defined]
+    else:
+        bindings = keymap.get_action_keys()
+    for binding in bindings:
+        emit_debug_event(
+            "keybinding.register",
+            category="keybinding",
+            source="snapshot",
+            kind="action",
+            provider=keymap.__class__.__name__,
+            key=binding.key,
+            action=binding.action,
+            context=binding.context,
+            guard=binding.guard,
+            primary=binding.primary,
+            show=binding.show,
+            priority=binding.priority,
+        )
+    if hasattr(keymap, "_action_emitted"):
+        try:
+            keymap._action_emitted = True  # type: ignore[attr-defined]
+        except Exception:
+            pass

sqlit/domains/connections/app/connection_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any, Protocol
 
@@ -25,6 +26,15 @@ class ConnectionFlow:
     services: AppServices
     connection_manager: Any | None = None
     prompter: ConnectionPrompter | None = None
+    emit_debug: Callable[..., None] | None = None
+
+    def _emit_debug(self, name: str, **data: Any) -> None:
+        if not self.emit_debug:
+            return
+        try:
+            self.emit_debug(name, **data)
+        except Exception:
+            pass
 
     def populate_credentials_if_missing(self, config: ConnectionConfig) -> None:
         """Populate missing credentials from the credentials service."""
@@ -47,12 +57,28 @@ def populate_credentials_if_missing(self, config: ConnectionConfig) -> None:
     def start(self, config: ConnectionConfig, on_ready: Any) -> None:
         """Start the connection flow, prompting for missing passwords as needed."""
         self.populate_credentials_if_missing(config)
+        self._emit_debug(
+            "connection_flow.start",
+            connection=config.name,
+            db_type=str(config.db_type),
+            needs_ssh=needs_ssh_password(config),
+            needs_db=needs_db_password(config),
+            has_db_password=bool(config.tcp_endpoint and config.tcp_endpoint.password is not None),
+            has_ssh_password=bool(config.tunnel and config.tunnel.password is not None),
+        )
 
         if needs_ssh_password(config):
             if not self.prompter:
+                self._emit_debug("connection_flow.ssh_prompt_missing", connection=config.name)
                 return
 
             def on_ssh_password(password: str | None) -> None:
+                self._emit_debug(
+                    "connection_flow.ssh_password",
+                    connection=config.name,
+                    provided=password is not None,
+                    value_len=len(password) if password is not None else 0,
+                )
                 if password is None:
                     return
                 temp_config = config.with_tunnel(password=password)
@@ -66,15 +92,29 @@ def on_ssh_password(password: str | None) -> None:
     def _with_db_password(self, config: ConnectionConfig, on_ready: Any) -> None:
         if needs_db_password(config):
             if not self.prompter:
+                self._emit_debug("connection_flow.db_prompt_missing", connection=config.name)
                 return
 
             def on_db_password(password: str | None) -> None:
+                self._emit_debug(
+                    "connection_flow.db_password",
+                    connection=config.name,
+                    provided=password is not None,
+                    value_len=len(password) if password is not None else 0,
+                )
                 if password is None:
                     return
                 temp_config = config.with_endpoint(password=password)
+                self._emit_debug(
+                    "connection_flow.ready",
+                    connection=config.name,
+                    db_type=str(config.db_type),
+                    source="db_prompt",
+                )
                 on_ready(temp_config)
 
             self.prompter.prompt_db_password(config, on_db_password)
             return
 
+        self._emit_debug("connection_flow.ready", connection=config.name, db_type=str(config.db_type))
         on_ready(config)

sqlit/domains/connections/app/url_parser.py

@@ -186,7 +186,13 @@ def _parse_server_based_url(
 ) -> ConnectionConfig:
     """Parse a server-based database URL (PostgreSQL, MySQL, etc.)."""
     hostname = parsed.hostname or ""
-    if not hostname:
+    schema = get_provider_schema(db_type)
+    requires_host = True
+    for field in schema.fields:
+        if field.name == "server":
+            requires_host = field.required
+            break
+    if requires_host and not hostname:
         raise ValueError(f"No host specified in URL: {original_url}")
 
     # Extract and decode credentials

sqlit/domains/connections/providers/postgresql/adapter.py

@@ -48,15 +48,17 @@ def connect(self, config: ConnectionConfig) -> Any:
         endpoint = config.tcp_endpoint
         if endpoint is None:
             raise ValueError("PostgreSQL connections require a TCP-style endpoint.")
-        port = int(endpoint.port or get_default_port("postgresql"))
         connect_args: dict[str, Any] = {
-            "host": endpoint.host,
-            "port": port,
-            "database": endpoint.database or "postgres",
-            "user": endpoint.username,
-            "password": endpoint.password,
             "connect_timeout": 10,
+            "database": endpoint.database or "postgres",
         }
+        if endpoint.host:
+            connect_args["host"] = endpoint.host
+            connect_args["port"] = int(endpoint.port or get_default_port("postgresql"))
+        if endpoint.username:
+            connect_args["user"] = endpoint.username
+        if endpoint.password is not None:
+            connect_args["password"] = endpoint.password
 
         tls_mode = get_tls_mode(config)
         tls_ca, tls_cert, tls_key, tls_key_password = get_tls_files(config)

sqlit/domains/connections/providers/postgresql/schema.py

@@ -15,10 +15,10 @@
     db_type="postgresql",
     display_name="PostgreSQL",
     fields=(
-        _server_field(),
+        _server_field(required=False),
         _port_field("5432"),
         _database_field(),
-        _username_field(),
+        _username_field(required=False),
         _password_field(),
     )
     + SSH_FIELDS

sqlit/domains/connections/providers/schema_helpers.py

@@ -57,12 +57,12 @@ class ConnectionSchema:
 
 # Common field templates
 
-def _server_field(placeholder: str = "localhost") -> SchemaField:
+def _server_field(placeholder: str = "localhost", required: bool = True) -> SchemaField:
     return SchemaField(
         name="server",
         label="Server",
         placeholder=placeholder,
-        required=True,
+        required=required,
         group="server_port",
     )