sqlide 0.1.0__py3-none-any.whl

sqlide/__init__.py

@@ -0,0 +1,3 @@
+"""sqlide: terminal SQL IDE over JDBC."""
+
+__version__ = "0.1.0"

sqlide/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from sqlide.cli import main
+
+sys.exit(main())

sqlide/app.py

@@ -0,0 +1,46 @@
+"""Textual application: only wires the workspace to the main screen."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App
+from textual.binding import Binding
+
+from sqlide.config.keymap import load_keymap
+from sqlide.config.settings import save_settings
+from sqlide.ui.commands import commands
+from sqlide.ui.screens.main import MainScreen
+from sqlide.workspace import Workspace
+
+
+class SqlideApp(App):
+    CSS_PATH = str(Path(__file__).parent / "ui" / "app.tcss")
+    BINDINGS = [Binding("ctrl+q", "quit", "Quit", priority=True, id="app.quit")]
+
+    def __init__(self, workspace: Workspace | None = None, files: list[Path] | None = None) -> None:
+        super().__init__()
+        self.workspace = workspace or Workspace()
+        self._files = files or []
+
+    def on_mount(self) -> None:
+        self.set_keymap(load_keymap())  # user overrides from keymap.toml
+        if self.workspace.settings.theme in self.available_themes:
+            self.theme = self.workspace.settings.theme
+        self.theme_changed_signal.subscribe(self, self._remember_theme)
+        self.main = MainScreen(self.workspace, self._files)
+        self.push_screen(self.main)
+
+    def _remember_theme(self, theme) -> None:
+        settings = self.workspace.settings
+        if theme.name != settings.theme:
+            settings.theme = theme.name
+            save_settings(settings)
+
+    def get_system_commands(self, screen):
+        yield from super().get_system_commands(screen)
+        yield from commands(self)
+
+    async def action_quit(self) -> None:
+        await self.main.tabs.shutdown()  # save consoles, cancel queries, close connections
+        self.exit()

sqlide/cli.py

@@ -0,0 +1,64 @@
+"""Command line entry point. Thin: dispatch only, no logic."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from sqlide import __version__
+from sqlide.drivers import cli as driver_cli
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="sqlide", description="Terminal SQL IDE over JDBC")
+    p.add_argument("--version", action="version", version=f"sqlide {__version__}")
+    sub = p.add_subparsers(dest="command")
+    d = sub.add_parser("doctor", help="check environment (JVM, drivers, config dirs)")
+    d.set_defaults(handler=lambda _: _doctor())
+    k = sub.add_parser("keys", help="list rebindable keys (override in keymap.toml)")
+    k.set_defaults(handler=lambda _: _keys())
+    driver_cli.register(sub)
+    return p
+
+
+def _doctor() -> int:
+    from sqlide import doctor
+
+    return doctor.run()
+
+
+def _keys() -> int:
+    from sqlide.config import paths
+    from sqlide.ui.keymap import catalogue
+
+    print(f'Override in {paths.keymap_file()}  ([keys] id = "key,key")\n')
+    infos = catalogue()
+    width = max(len(i.id) for i in infos)
+    for i in infos:
+        print(f"{i.id:<{width}}  {i.keys:<40}  {i.description}")
+    return 0
+
+
+COMMANDS = {"doctor", "driver", "keys"}
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if argv is None else argv
+    if argv and argv[0] not in COMMANDS and not argv[0].startswith("-"):
+        return _run_tui([Path(a) for a in argv])  # `sqlide query.sql other.sql`
+    args = build_parser().parse_args(argv)
+    if getattr(args, "handler", None):
+        return args.handler(args)
+    return _run_tui([])
+
+
+def _run_tui(files: list[Path]) -> int:
+    from sqlide.app import SqlideApp
+
+    SqlideApp(files=files).run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sqlide/clipboard.py

@@ -0,0 +1,65 @@
+"""System clipboard across macOS, Linux (X11/Wayland), WSL; OSC52 as the last resort."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from collections.abc import Callable
+from pathlib import Path
+
+Backend = tuple[str, list[str], Callable[[str], bytes]]
+
+
+def _utf8(s: str) -> bytes:
+    return s.encode("utf-8")
+
+
+def _utf16(s: str) -> bytes:  # clip.exe reads UTF-16LE when a BOM is present
+    return b"\xff\xfe" + s.encode("utf-16-le")
+
+
+def is_wsl() -> bool:
+    try:
+        return "microsoft" in Path("/proc/version").read_text().lower()
+    except OSError:
+        return False
+
+
+def backends(platform: str | None = None, wsl: bool | None = None) -> list[Backend]:
+    """Installed native clipboard tools in preference order."""
+    import sys
+
+    platform = platform or sys.platform
+    wsl = is_wsl() if wsl is None else wsl
+    candidates: list[Backend] = []
+    if platform == "darwin":
+        candidates.append(("pbcopy", ["pbcopy"], _utf8))
+    elif platform == "win32":
+        candidates.append(("clip", ["clip"], _utf16))
+    else:
+        if os.environ.get("WAYLAND_DISPLAY"):
+            candidates.append(("wl-copy", ["wl-copy"], _utf8))
+        if os.environ.get("DISPLAY"):
+            candidates.append(("xclip", ["xclip", "-selection", "clipboard", "-i"], _utf8))
+            candidates.append(("xsel", ["xsel", "--clipboard", "--input"], _utf8))
+        if wsl:
+            candidates.append(("clip.exe", ["clip.exe"], _utf16))
+    return [c for c in candidates if shutil.which(c[1][0])]
+
+
+def copy_native(text: str) -> str | None:
+    """Copy via the first working tool. Returns its name, or None if none worked."""
+    for name, cmd, encode in backends():
+        try:
+            subprocess.run(cmd, input=encode(text), check=True, timeout=5, capture_output=True)
+            return name
+        except (OSError, subprocess.SubprocessError):
+            continue
+    return None
+
+
+def available() -> str:
+    """Human-readable description for `sqlide doctor`."""
+    found = backends()
+    return found[0][0] if found else "none (falls back to OSC52 terminal escape)"

sqlide/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration block: paths, settings, saved connections, password resolution."""

sqlide/config/_toml.py

@@ -0,0 +1,41 @@
+"""Tiny TOML IO shared by config modules: tolerant read, atomic write."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+
+class ConfigError(Exception):
+    """Config file is unreadable or invalid."""
+
+
+def read_toml(path: Path) -> dict[str, Any]:
+    """Return {} when the file is missing; raise ConfigError when it is malformed."""
+    try:
+        with path.open("rb") as f:
+            return tomllib.load(f)
+    except FileNotFoundError:
+        return {}
+    except tomllib.TOMLDecodeError as e:
+        raise ConfigError(f"{path}: {e}") from e
+
+
+def write_toml(path: Path, data: dict[str, Any], *, private: bool = False) -> None:
+    """Write atomically (temp file + rename) so a crash never leaves a half file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")
+    try:
+        with os.fdopen(fd, "wb") as f:
+            tomli_w.dump(data, f)
+        if private:
+            os.chmod(tmp, 0o600)
+        os.replace(tmp, path)
+    except BaseException:
+        Path(tmp).unlink(missing_ok=True)
+        raise

sqlide/config/connections.py

@@ -0,0 +1,76 @@
+"""Saved connections. Passwords are never stored: only a reference or nothing."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from sqlide.config import paths
+from sqlide.config._toml import ConfigError, read_toml, write_toml
+
+ENV_REF = re.compile(r"^\$\{env:([A-Za-z_][A-Za-z0-9_]*)\}$")
+
+
+@dataclass(slots=True)
+class Connection:
+    name: str
+    driver: str  # driver id, see drivers registry
+    url: str  # JDBC url, e.g. jdbc:postgresql://host:5432/db
+    user: str = ""
+    password_ref: str = ""  # "" = ask on connect, or "${env:VAR}"
+    password_cmd: str = ""  # shell-free command whose stdout is the password
+    properties: dict[str, str] = field(default_factory=dict)
+    autocommit: bool = True
+
+    def __post_init__(self) -> None:
+        if not self.name.strip():
+            raise ConfigError("connection name is empty")
+        if self.password_ref and not ENV_REF.match(self.password_ref):
+            raise ConfigError(
+                f"{self.name}: password_ref must look like ${{env:VAR}}, "
+                "plain passwords are not stored"
+            )
+
+
+class ConnectionStore:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or paths.connections_file()
+
+    def load(self) -> list[Connection]:
+        raw = read_toml(self.path)
+        out = []
+        for item in raw.get("connection", []):
+            try:
+                out.append(Connection(**item))
+            except TypeError as e:
+                raise ConfigError(f"{self.path}: bad connection entry: {e}") from e
+        return out
+
+    def save(self, connections: list[Connection]) -> None:
+        names = [c.name for c in connections]
+        if len(names) != len(set(names)):
+            raise ConfigError("duplicate connection names")
+        data: dict[str, Any] = {"connection": [_to_dict(c) for c in connections]}
+        write_toml(self.path, data, private=True)
+
+    def upsert(self, conn: Connection) -> None:
+        items = [c for c in self.load() if c.name != conn.name]
+        self.save([*items, conn])
+
+    def remove(self, name: str) -> None:
+        self.save([c for c in self.load() if c.name != name])
+
+
+def _to_dict(c: Connection) -> dict[str, Any]:
+    return {
+        "name": c.name,
+        "driver": c.driver,
+        "url": c.url,
+        "user": c.user,
+        "password_ref": c.password_ref,
+        "password_cmd": c.password_cmd,
+        "properties": c.properties,
+        "autocommit": c.autocommit,
+    }

sqlide/config/keymap.py

@@ -0,0 +1,25 @@
+"""User key overrides: keymap.toml maps binding ids to key strings.
+
+    [keys]
+    "editor.run" = "f6"
+    "main.history" = "ctrl+h,alt+e"     # several keys: comma separated
+
+`sqlide keys` lists every id with its default. Bad entries are ignored, never fatal.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from sqlide.config import paths
+from sqlide.config._toml import ConfigError, read_toml
+
+
+def load_keymap(path: Path | None = None) -> dict[str, str]:
+    try:
+        raw = read_toml(path or paths.keymap_file()).get("keys", {})
+    except ConfigError:
+        return {}
+    if not isinstance(raw, dict):
+        return {}
+    return {k: v.strip() for k, v in raw.items() if isinstance(v, str) and v.strip()}

sqlide/config/paths.py

@@ -0,0 +1,48 @@
+"""Filesystem locations. Env overrides exist for tests and portable installs."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from platformdirs import user_config_path, user_data_path
+
+APP = "sqlide"
+
+
+def config_dir() -> Path:
+    override = os.environ.get("SQLIDE_CONFIG_DIR")
+    return Path(override) if override else user_config_path(APP)
+
+
+def data_dir() -> Path:
+    override = os.environ.get("SQLIDE_DATA_DIR")
+    return Path(override) if override else user_data_path(APP)
+
+
+def settings_file() -> Path:
+    return config_dir() / "settings.toml"
+
+
+def connections_file() -> Path:
+    return config_dir() / "connections.toml"
+
+
+def keymap_file() -> Path:
+    return config_dir() / "keymap.toml"
+
+
+def drivers_file() -> Path:
+    return config_dir() / "drivers.toml"
+
+
+def drivers_dir() -> Path:
+    return data_dir() / "drivers"
+
+
+def history_db() -> Path:
+    return data_dir() / "history.sqlite"
+
+
+def consoles_dir() -> Path:
+    return data_dir() / "consoles"

sqlide/config/secrets.py

@@ -0,0 +1,82 @@
+"""Password resolution. Order: password_cmd -> ${env:VAR} -> prompt callback.
+
+The session cache lives in memory only and dies with the process.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from collections.abc import Callable
+
+from sqlide.config._toml import ConfigError
+from sqlide.config.connections import ENV_REF, Connection
+
+CMD_TIMEOUT_S = 10
+
+Prompt = Callable[[Connection], str | None]  # None = user cancelled
+
+
+def _split(cmd: str) -> list[str]:
+    if os.name != "nt":
+        return shlex.split(cmd)
+    # non-POSIX split keeps the quotes around tokens; strip them like CreateProcess would
+    return [
+        t[1:-1] if len(t) > 1 and t[0] == t[-1] == '"' else t for t in shlex.split(cmd, posix=False)
+    ]
+
+
+class PasswordResolver:
+    def __init__(self) -> None:
+        self._cache: dict[str, str] = {}
+
+    def lookup(self, conn: Connection) -> str | None:
+        """Non-interactive sources only. None = the user has to be asked. May block (cmd)."""
+        if conn.name in self._cache:
+            return self._cache[conn.name]
+        password = self._from_cmd(conn) or self._from_env(conn)
+        if password is not None:
+            self._cache[conn.name] = password
+        return password
+
+    def store(self, name: str, password: str) -> None:
+        self._cache[name] = password
+
+    def resolve(self, conn: Connection, prompt: Prompt) -> str | None:
+        """Sync convenience: lookup, else ask via `prompt` (UI code uses lookup/store)."""
+        password = self.lookup(conn)
+        if password is None:
+            password = prompt(conn)
+            if password is not None:
+                self.store(conn.name, password)
+        return password
+
+    def forget(self, name: str) -> None:
+        self._cache.pop(name, None)
+
+    @staticmethod
+    def _from_cmd(conn: Connection) -> str | None:
+        if not conn.password_cmd:
+            return None
+        try:
+            res = subprocess.run(
+                _split(conn.password_cmd),
+                capture_output=True,
+                text=True,
+                timeout=CMD_TIMEOUT_S,
+                check=True,
+            )
+        except (OSError, subprocess.SubprocessError) as e:
+            raise ConfigError(f"{conn.name}: password_cmd failed: {e}") from e
+        return res.stdout.rstrip("\r\n")
+
+    @staticmethod
+    def _from_env(conn: Connection) -> str | None:
+        m = ENV_REF.match(conn.password_ref)
+        if not m:
+            return None
+        value = os.environ.get(m.group(1))
+        if value is None:
+            raise ConfigError(f"{conn.name}: env var {m.group(1)} is not set")
+        return value

sqlide/config/settings.py

@@ -0,0 +1,32 @@
+"""User settings. Unknown keys in the file are ignored; bad values fall back to defaults."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, fields
+from pathlib import Path
+
+from sqlide.config import paths
+from sqlide.config._toml import read_toml, write_toml
+
+
+@dataclass(slots=True)
+class Settings:
+    fetch_size: int = 500  # rows per page
+    split_on_blank_line: bool = True  # blank line ends a statement (DataGrip-like)
+    autosave_consoles: bool = True
+    theme: str = "textual-dark"
+    history_limit: int = 5000
+
+
+def load_settings(path: Path | None = None) -> Settings:
+    raw = read_toml(path or paths.settings_file())
+    defaults = Settings()
+    values = {}
+    for f in fields(Settings):
+        if f.name in raw and type(raw[f.name]) is type(getattr(defaults, f.name)):
+            values[f.name] = raw[f.name]
+    return Settings(**values)
+
+
+def save_settings(settings: Settings, path: Path | None = None) -> None:
+    write_toml(path or paths.settings_file(), asdict(settings))

sqlide/consoles.py

@@ -0,0 +1,100 @@
+"""Console files and the list of open tabs. Pure storage: no UI, no JVM.
+
+Consoles are scratch SQL files owned by the app: ``consoles/<connection>/console_N.sql``,
+autosaved. Files opened by the user are saved only on request. The tab list is kept in
+``state.toml`` so the next start reopens the same tabs.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from sqlide.config import paths
+from sqlide.config._toml import ConfigError, read_toml, write_toml
+
+CONSOLE, FILE = "console", "file"
+
+
+@dataclass(slots=True)
+class TabState:
+    kind: str  # CONSOLE | FILE
+    path: str
+    connection: str = ""  # intended connection name; connected lazily
+    active: bool = False
+
+
+def safe_dirname(name: str) -> str:
+    return re.sub(r"[^\w.\-]+", "_", name).strip("._") or "_"
+
+
+def write_text_atomic(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="") as f:
+            f.write(text)
+        os.replace(tmp, path)
+    except BaseException:
+        Path(tmp).unlink(missing_ok=True)
+        raise
+
+
+class ConsoleStore:
+    def __init__(self, root: Path | None = None, state_file: Path | None = None) -> None:
+        self.root = root or paths.consoles_dir()
+        self.state_file = state_file or (paths.data_dir() / "state.toml")
+
+    def new_console_file(self, connection: str | None) -> Path:
+        """Reserve the next free ``console_N.sql`` for a connection (or no connection)."""
+        folder = self.root / safe_dirname(connection or "no-connection")
+        folder.mkdir(parents=True, exist_ok=True)
+        used = [
+            int(m.group(1))
+            for f in self.root.glob("*/console_*.sql")
+            if (m := re.fullmatch(r"console_(\d+)\.sql", f.name))
+        ]
+        n = max(used, default=0) + 1  # unique across connections, so tab titles differ
+        path = folder / f"console_{n}.sql"
+        path.touch()
+        return path
+
+    @staticmethod
+    def read(path: Path) -> tuple[str, str]:
+        """(text normalised to '\\n', original newline style) so saving can restore it."""
+        with path.open(encoding="utf-8", newline="") as f:
+            raw = f.read()
+        newline = "\r\n" if "\r\n" in raw else "\n"
+        return raw.replace("\r\n", "\n").replace("\r", "\n"), newline
+
+    @staticmethod
+    def write(path: Path, text: str, newline: str = "\n") -> None:
+        write_text_atomic(path, text.replace("\n", newline) if newline != "\n" else text)
+
+    # --- tab list ---
+    def load_state(self) -> list[TabState]:
+        try:
+            raw = read_toml(self.state_file).get("tab", [])
+        except ConfigError:
+            return []  # a damaged state file must never stop the app from starting
+        tabs = []
+        for item in raw:
+            try:
+                tabs.append(TabState(**item))
+            except TypeError:
+                continue
+        return [t for t in tabs if t.kind in (CONSOLE, FILE)]
+
+    def save_state(self, tabs: list[TabState]) -> None:
+        write_toml(
+            self.state_file,
+            {
+                "tab": [
+                    {"kind": t.kind, "path": t.path, "connection": t.connection, "active": t.active}
+                    for t in tabs
+                ]
+            },
+        )

sqlide/db/__init__.py

@@ -0,0 +1 @@
+"""DB block: JDBC sessions, typed results. Knows nothing about the UI."""