ghostbase-cli 0.1.0__py3-none-any.whl

db_engine.py

@@ -0,0 +1,396 @@
+import sqlite3
+import time
+import urllib.parse
+import re
+from typing import List, Dict, Any, Tuple
+
+
+class DatabaseEngine:
+    """Database connection and query handler for SQLite, Postgres, and MySQL."""
+
+    def __init__(self, connection_string: str = None):
+        self.connection_string = (connection_string or "sample.db").strip()
+        self.db_type = "sqlite"
+        self.db_name = ""
+        self.conn = None
+        self._parse_and_connect()
+
+    # --- Connection handling ---
+
+    def _parse_and_connect(self):
+        cs = self.connection_string
+        if cs.startswith(("postgresql://", "postgres://")):
+            self.db_type = "postgresql"
+            parsed = urllib.parse.urlparse(cs)
+            self.db_name = parsed.path.lstrip("/")
+            self._connect_postgres(cs)
+        elif cs.startswith("mysql://"):
+            self.db_type = "mysql"
+            parsed = urllib.parse.urlparse(cs)
+            self.db_name = parsed.path.lstrip("/")
+            self._connect_mysql(cs)
+        else:
+            self.db_type = "sqlite"
+            path = cs.removeprefix("sqlite:///")
+            self.db_name = path
+            self._connect_sqlite(path)
+
+    def _connect_sqlite(self, path: str):
+        self.conn = sqlite3.connect(path, check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+
+    def _connect_postgres(self, url: str):
+        try:
+            import psycopg2
+        except ImportError:
+            raise RuntimeError(
+                "psycopg2 is not installed.\n"
+                "Run:  pip install psycopg2-binary"
+            )
+        self.conn = psycopg2.connect(url)
+        self.conn.autocommit = False
+
+    def _connect_mysql(self, url: str):
+        try:
+            import pymysql
+            import pymysql.cursors
+        except ImportError:
+            raise RuntimeError(
+                "pymysql is not installed.\n"
+                "Run:  pip install pymysql"
+            )
+        parsed = urllib.parse.urlparse(url)
+        self.conn = pymysql.connect(
+            host=parsed.hostname or "localhost",
+            port=parsed.port or 3306,
+            user=parsed.username or "root",
+            password=parsed.password or "",
+            database=parsed.path.lstrip("/"),
+            cursorclass=pymysql.cursors.DictCursor,
+            autocommit=True,
+        )
+
+    # --- Schema discovery ---
+
+    def get_tables(self) -> List[str]:
+        try:
+            cur = self.conn.cursor()
+            if self.db_type == "sqlite":
+                cur.execute(
+                    "SELECT name FROM sqlite_master "
+                    "WHERE type='table' AND name NOT LIKE 'sqlite_%' "
+                    "ORDER BY name;"
+                )
+                return [r[0] for r in cur.fetchall()]
+            elif self.db_type == "postgresql":
+                cur.execute(
+                    "SELECT table_name FROM information_schema.tables "
+                    "WHERE table_schema='public' AND table_type='BASE TABLE' "
+                    "ORDER BY table_name;"
+                )
+                return [r[0] for r in cur.fetchall()]
+            elif self.db_type == "mysql":
+                cur.execute("SHOW FULL TABLES WHERE Table_type = 'BASE TABLE';")
+                rows = cur.fetchall()
+                return [list(r.values())[0] if isinstance(r, dict) else r[0] for r in rows]
+        except Exception:
+            return []
+        return []
+
+    def get_views(self) -> List[str]:
+        try:
+            cur = self.conn.cursor()
+            if self.db_type == "sqlite":
+                cur.execute(
+                    "SELECT name FROM sqlite_master WHERE type='view' ORDER BY name;"
+                )
+                return [r[0] for r in cur.fetchall()]
+            elif self.db_type == "postgresql":
+                cur.execute(
+                    "SELECT table_name FROM information_schema.views "
+                    "WHERE table_schema='public' ORDER BY table_name;"
+                )
+                return [r[0] for r in cur.fetchall()]
+            elif self.db_type == "mysql":
+                cur.execute("SHOW FULL TABLES WHERE Table_type = 'VIEW';")
+                rows = cur.fetchall()
+                return [list(r.values())[0] if isinstance(r, dict) else r[0] for r in rows]
+        except Exception:
+            return []
+        return []
+
+    def get_table_schema(self, table_name: str) -> List[Dict[str, Any]]:
+        try:
+            cur = self.conn.cursor()
+            if self.db_type == "sqlite":
+                cur.execute(f"PRAGMA table_info([{table_name}]);")
+                return [
+                    {"name": r[1], "type": r[2], "notnull": r[3],
+                     "dflt_value": r[4], "pk": r[5]}
+                    for r in cur.fetchall()
+                ]
+            elif self.db_type == "postgresql":
+                cur.execute(
+                    """
+                    SELECT
+                        c.column_name,
+                        c.data_type,
+                        CASE WHEN c.is_nullable = 'NO' THEN 1 ELSE 0 END,
+                        c.column_default,
+                        CASE WHEN kcu.column_name IS NOT NULL THEN 1 ELSE 0 END
+                    FROM information_schema.columns c
+                    LEFT JOIN information_schema.table_constraints tc
+                        ON tc.table_name = c.table_name
+                        AND tc.constraint_type = 'PRIMARY KEY'
+                        AND tc.table_schema = 'public'
+                    LEFT JOIN information_schema.key_column_usage kcu
+                        ON kcu.constraint_name = tc.constraint_name
+                        AND kcu.column_name = c.column_name
+                    WHERE c.table_name = %s AND c.table_schema = 'public'
+                    ORDER BY c.ordinal_position;
+                    """,
+                    (table_name,),
+                )
+                return [
+                    {"name": r[0], "type": r[1], "notnull": r[2],
+                     "dflt_value": r[3], "pk": r[4]}
+                    for r in cur.fetchall()
+                ]
+            elif self.db_type == "mysql":
+                cur.execute(f"DESCRIBE `{table_name}`;")
+                rows = cur.fetchall()
+                result = []
+                for r in rows:
+                    d = r if isinstance(r, dict) else dict(
+                        zip(["Field", "Type", "Null", "Key", "Default", "Extra"], r)
+                    )
+                    result.append({
+                        "name": d.get("Field", ""),
+                        "type": d.get("Type", ""),
+                        "notnull": 1 if d.get("Null") == "NO" else 0,
+                        "dflt_value": d.get("Default"),
+                        "pk": 1 if d.get("Key") == "PRI" else 0,
+                    })
+                return result
+        except Exception:
+            return []
+        return []
+
+    def get_foreign_keys(self, table_name: str) -> List[Dict[str, str]]:
+        try:
+            cur = self.conn.cursor()
+            if self.db_type == "sqlite":
+                cur.execute(f"PRAGMA foreign_key_list([{table_name}]);")
+                return [
+                    {"from": r[3], "to_table": r[2], "to_col": r[4]}
+                    for r in cur.fetchall()
+                ]
+            elif self.db_type == "postgresql":
+                cur.execute(
+                    """
+                    SELECT kcu.column_name,
+                           ccu.table_name AS to_table,
+                           ccu.column_name AS to_col
+                    FROM information_schema.table_constraints tc
+                    JOIN information_schema.key_column_usage kcu
+                        ON tc.constraint_name = kcu.constraint_name
+                        AND tc.table_schema = kcu.table_schema
+                    JOIN information_schema.constraint_column_usage ccu
+                        ON ccu.constraint_name = tc.constraint_name
+                        AND ccu.table_schema = tc.table_schema
+                    WHERE tc.constraint_type = 'FOREIGN KEY'
+                      AND tc.table_name = %s;
+                    """,
+                    (table_name,),
+                )
+                return [
+                    {"from": r[0], "to_table": r[1], "to_col": r[2]}
+                    for r in cur.fetchall()
+                ]
+            elif self.db_type == "mysql":
+                cur.execute("SELECT DATABASE();")
+                row = cur.fetchone()
+                db = list(row.values())[0] if isinstance(row, dict) else row[0]
+                cur.execute(
+                    """
+                    SELECT COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+                    FROM information_schema.KEY_COLUMN_USAGE
+                    WHERE TABLE_SCHEMA = %s AND TABLE_NAME = %s
+                      AND REFERENCED_TABLE_NAME IS NOT NULL;
+                    """,
+                    (db, table_name),
+                )
+                rows = cur.fetchall()
+                return [
+                    {
+                        "from": (r.get("COLUMN_NAME") if isinstance(r, dict) else r[0]),
+                        "to_table": (r.get("REFERENCED_TABLE_NAME") if isinstance(r, dict) else r[1]),
+                        "to_col": (r.get("REFERENCED_COLUMN_NAME") if isinstance(r, dict) else r[2]),
+                    }
+                    for r in rows
+                ]
+        except Exception:
+            return []
+        return []
+
+    def get_row_count(self, table_name: str) -> int:
+        try:
+            cur = self.conn.cursor()
+            if self.db_type == "sqlite":
+                cur.execute(f"SELECT COUNT(*) FROM [{table_name}];")
+            elif self.db_type == "postgresql":
+                cur.execute(f'SELECT COUNT(*) FROM "{table_name}";')
+            else:
+                cur.execute(f"SELECT COUNT(*) FROM `{table_name}`;")
+            row = cur.fetchone()
+            val = list(row.values())[0] if isinstance(row, dict) else row[0]
+            return int(val)
+        except Exception:
+            return 0
+
+    # --- Query safety and formatting ---
+
+    def check_safety(self, query: str) -> Tuple[bool, str]:
+        """Detect destructive operations without WHERE clauses or schema drops."""
+        q_clean = re.sub(r"--.*$", "", query, flags=re.MULTILINE)
+        q_upper = q_clean.strip().upper()
+
+        if re.search(r"\bDROP\s+(TABLE|DATABASE|SCHEMA|VIEW)\b", q_upper):
+            return True, "DROP operation detected"
+        if re.search(r"\bTRUNCATE\b", q_upper):
+            return True, "TRUNCATE operation detected"
+        if re.search(r"\bDELETE\s+FROM\b", q_upper) and not re.search(r"\bWHERE\b", q_upper):
+            return True, "DELETE without WHERE clause (will delete all rows)"
+        if re.search(r"\bUPDATE\b", q_upper) and not re.search(r"\bWHERE\b", q_upper):
+            return True, "UPDATE without WHERE clause (will modify all rows)"
+        if re.search(r"\bALTER\s+TABLE\s+.*\bDROP\b", q_upper):
+            return True, "ALTER TABLE DROP detected"
+
+        return False, ""
+
+    def explain_query(self, query: str) -> Dict[str, Any]:
+        clean_q = re.sub(r"--.*$", "", query, flags=re.MULTILINE).strip().rstrip(";")
+        if not clean_q:
+            return {"success": False, "error": "Query is empty"}
+
+        if self.db_type == "sqlite":
+            explain_sql = f"EXPLAIN QUERY PLAN {clean_q};"
+        else:
+            explain_sql = f"EXPLAIN {clean_q};"
+        return self.execute_query(explain_sql)
+
+    @staticmethod
+    def format_sql(query: str) -> str:
+        """Format and uppercase SQL keywords with line indents."""
+        if not query or not query.strip():
+            return query
+
+        lines = query.strip().splitlines()
+        comment_lines = []
+        sql_lines = []
+        for line in lines:
+            if line.strip().startswith("--"):
+                comment_lines.append(line.strip())
+            else:
+                sql_lines.append(line)
+
+        sql_text = " ".join(sql_lines)
+        sql_text = re.sub(r"\s+", " ", sql_text).strip()
+
+        keywords = [
+            "SELECT", "FROM", "WHERE", "AND", "OR", "ORDER BY",
+            "GROUP BY", "HAVING", "LEFT JOIN", "RIGHT JOIN",
+            "INNER JOIN", "CROSS JOIN", "JOIN", "ON", "INSERT INTO",
+            "VALUES", "UPDATE", "SET", "DELETE FROM", "DELETE",
+            "LIMIT", "OFFSET", "AS", "CREATE TABLE", "CREATE VIEW",
+            "DROP TABLE", "DROP VIEW", "ALTER TABLE", "PRIMARY KEY",
+            "FOREIGN KEY", "REFERENCES", "DEFAULT", "NOT NULL",
+            "AUTOINCREMENT", "DESC", "ASC", "UNION ALL", "UNION",
+            "DISTINCT", "EXPLAIN QUERY PLAN", "EXPLAIN", "IN", "IS NULL",
+            "IS NOT NULL", "LIKE", "BETWEEN", "CASE", "WHEN", "THEN", "ELSE", "END",
+            "COUNT", "SUM", "AVG", "MIN", "MAX"
+        ]
+        keywords.sort(key=len, reverse=True)
+
+        for kw in keywords:
+            pattern = rf"\b{re.escape(kw)}\b"
+            sql_text = re.sub(pattern, kw, sql_text, flags=re.IGNORECASE)
+
+        major_clauses = [
+            "LEFT JOIN", "RIGHT JOIN", "INNER JOIN", "CROSS JOIN",
+            "FROM", "WHERE", "GROUP BY", "ORDER BY", "HAVING", "LIMIT",
+            "OFFSET", "SET", "VALUES"
+        ]
+        for clause in major_clauses:
+            sql_text = re.sub(rf"\b({clause})\b", r"\n\1", sql_text)
+        sql_text = re.sub(r"(?<!LEFT\s)(?<!RIGHT\s)(?<!INNER\s)(?<!CROSS\s)\bJOIN\b", r"\nJOIN", sql_text)
+
+        sql_text = re.sub(r"\b(AND|OR)\b", r"\n  \1", sql_text)
+
+        result_parts = []
+        if comment_lines:
+            result_parts.append("\n".join(comment_lines))
+        result_parts.append(sql_text.strip())
+        return "\n".join(result_parts)
+
+    # --- Query execution ---
+
+    def execute_query(self, query: str) -> Dict[str, Any]:
+        start = time.perf_counter()
+        try:
+            cur = self.conn.cursor()
+            cur.execute(query)
+            elapsed_ms = (time.perf_counter() - start) * 1000
+
+            if cur.description:
+                columns = [d[0] for d in cur.description]
+                raw = cur.fetchall()
+                rows = []
+                for r in raw:
+                    if isinstance(r, dict):
+                        rows.append(list(r.values()))
+                    else:
+                        rows.append(list(r))
+                return {
+                    "success": True,
+                    "columns": columns,
+                    "rows": rows,
+                    "row_count": len(rows),
+                    "elapsed_ms": round(elapsed_ms, 2),
+                    "is_select": True,
+                }
+            else:
+                if self.db_type in ("sqlite", "postgresql"):
+                    self.conn.commit()
+                return {
+                    "success": True,
+                    "affected_rows": max(cur.rowcount, 0),
+                    "elapsed_ms": round(elapsed_ms, 2),
+                    "is_select": False,
+                }
+        except Exception as e:
+            elapsed_ms = (time.perf_counter() - start) * 1000
+            if self.db_type == "postgresql":
+                try:
+                    self.conn.rollback()
+                except Exception:
+                    pass
+            return {
+                "success": False,
+                "error": str(e),
+                "elapsed_ms": round(elapsed_ms, 2),
+            }
+
+    # --- Helpers ---
+
+    def db_type_label(self) -> str:
+        return {"sqlite": "SQLite", "postgresql": "PostgreSQL", "mysql": "MySQL"}.get(
+            self.db_type, self.db_type.upper()
+        )
+
+    def close(self):
+        if self.conn:
+            try:
+                self.conn.close()
+            except Exception:
+                pass

exporter.py

@@ -0,0 +1,55 @@
+import csv
+import json
+from typing import List, Any
+
+
+class Exporter:
+    @staticmethod
+    def to_csv(columns: List[str], rows: List[List[Any]], output_path: str):
+        with open(output_path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.writer(f)
+            writer.writerow(columns)
+            writer.writerows(rows)
+
+    @staticmethod
+    def to_json(columns: List[str], rows: List[List[Any]], output_path: str):
+        data = []
+        for r in rows:
+            data.append(dict(zip(columns, r)))
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+    @staticmethod
+    def to_markdown(columns: List[str], rows: List[List[Any]], output_path: str):
+        with open(output_path, "w", encoding="utf-8") as f:
+            # Header
+            f.write("| " + " | ".join(str(c) for c in columns) + " |\n")
+            # Separator
+            f.write("| " + " | ".join("---" for _ in columns) + " |\n")
+            # Rows
+            for r in rows:
+                clean_cells = [
+                    (str(val).replace("|", "\\|").replace("\n", " ") if val is not None else "NULL")
+                    for val in r
+                ]
+                f.write("| " + " | ".join(clean_cells) + " |\n")
+
+    @staticmethod
+    def to_sql_inserts(table_name: str, columns: List[str], rows: List[List[Any]], output_path: str):
+        table = table_name or "exported_table"
+        cols_str = ", ".join(columns)
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(f"-- GhostBase SQL Export: {table}\n")
+            f.write(f"-- Total: {len(rows)} row(s)\n\n")
+            for r in rows:
+                vals = []
+                for v in r:
+                    if v is None:
+                        vals.append("NULL")
+                    elif isinstance(v, (int, float)):
+                        vals.append(str(v))
+                    else:
+                        escaped = str(v).replace("'", "''")
+                        vals.append(f"'{escaped}'")
+                vals_str = ", ".join(vals)
+                f.write(f"INSERT INTO {table} ({cols_str}) VALUES ({vals_str});\n")

ghostbase_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: ghostbase-cli
+Version: 0.1.0
+Summary: A fast, keyboard-driven terminal database studio for SQLite, PostgreSQL & MySQL
+Author-email: 4yk5 <contact.4yk5@proton.me>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/4yk5/GhostBase
+Project-URL: Repository, https://github.com/4yk5/GhostBase
+Project-URL: Issues, https://github.com/4yk5/GhostBase/issues
+Keywords: database,sql,tui,terminal,cli,sqlite,postgres,postgresql,mysql,dbeaver,datagrip,query,developer-tools
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=8.0.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: pymysql>=1.1.0
+Dynamic: license-file
+
+```
+   ____ _               _   ____                 
+  / ___| |__   ___  ___| |_| __ )  __ _ ___  ___ 
+ | |  _| '_ \ / _ \/ __| __|  _ \ / _` / __|/ _ \
+ | |_| | | | | (_) \__ \ |_| |_) | (_| \__ \  __/
+  \____|_| |_|\___/|___/\__|____/ \__,_|___/\___|
+                                                 
+```
+
+# GhostBase 👻🗄️
+
+> **A fast, keyboard-driven terminal database studio for SQLite, PostgreSQL, and MySQL.**  
+> *No Java runtimes. No 1.5GB RAM bloat. Built-in production safety guard, instant SQL beautifier & zero-config `.env` connect.*
+
+[![CI](https://github.com/4yk5/GhostBase/actions/workflows/ci.yml/badge.svg)](https://github.com/4yk5/GhostBase/actions)
+[![PyPI](https://img.shields.io/pypi/v/ghostbase-cli.svg)](https://pypi.org/project/ghostbase-cli/)
+[![Python: 3.10+](https://img.shields.io/badge/Python-3.10%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![UI: Textual](https://img.shields.io/badge/UI-Textual-bd93f9.svg)](https://github.com/Textualize/textual)
+
+---
+
+## ⚡ Why GhostBase?
+
+Opening **DBeaver** or **DataGrip** just to run a quick `SELECT`, inspect an index, or check foreign keys is painful:
+- ❌ **1.5 GB+ RAM bloat:** Heavy Java/Eclipse runtimes that spin your laptop fans.  
+  👉 **GhostBase idles at ~25 MB RAM.**
+- ❌ **15-Second Cold Starts:** Splash screens, driver updates, and workspace indexing.  
+  👉 **GhostBase starts in under 120 ms directly in your terminal.**
+- ❌ **Accidental Destructive Queries on Production:** Running `DELETE` or `UPDATE` without a `WHERE` clause can wipe production tables.  
+  👉 **GhostBase intercepts destructive queries automatically with double-confirmation and one-key Read-Only Safe Mode (`Ctrl + S`).**
+- ❌ **Messy, Unformatted Queries:** Manually formatting and indenting long SQL statements.  
+  👉 **GhostBase auto-formats and beautifies messy SQL queries with one keypress (`Ctrl + B`).**
+- ❌ **Tedious Connection Setup:** Typing credentials into multi-tab dialogs.  
+  👉 **GhostBase auto-detects `DATABASE_URL` from your local `.env` file.**
+- ❌ **Seeding & Migrating Data:** Manually writing `INSERT INTO` statements to replicate test rows.  
+  👉 **GhostBase exports query results directly into executable SQL `INSERT` statements (`Ctrl + I`).**
+- ❌ **Exporting for GitHub / Jira / Notion:** Exporting CSV, then finding a website to convert to Markdown.  
+  👉 **One-key instant Markdown table export (`Ctrl + M`) directly into clean GitHub Flavored Markdown.**
+
+---
+
+## 🚀 Killer Features
+
+- 🛡️ **Production Safety Guard & Safe Mode (`Ctrl + S`):**
+  - Intercepts dangerous statements (`DELETE`/`UPDATE` without `WHERE`, `DROP TABLE`, `TRUNCATE`).
+  - In **Safe Mode**, all destructive operations are strictly blocked.
+  - In normal mode, requires explicit double-confirmation before execution.
+- ✨ **1-Key SQL Beautifier (`Ctrl + B`):**
+  - Instantly cleans up whitespace, capitalizes SQL keywords, and indents sub-clauses (`FROM`, `WHERE`, `AND`, `OR`, `JOIN`, `ORDER BY`).
+- ⚡ **1-Key Query Plan (`Ctrl + P`):**
+  - Run instant execution plans (`EXPLAIN QUERY PLAN` / `EXPLAIN`) on any query to see index usage and bottlenecks.
+- 🔌 **Universal Database Support:** Connects natively to **SQLite**, **PostgreSQL**, and **MySQL**.
+- 🔍 **Zero-Config `.env` Auto-Connect:** Just run `ghostbase` in any project folder; it automatically picks up `DATABASE_URL` or standard database environment variables.
+- 🔎 **Real-time Table Search (`Ctrl + F`):** Type in the search bar to filter dozens of tables and views instantly.
+- 📊 **Explorer with Tables & Views:** Browse tables and views with live row counts.
+- 📐 **Instant Schema & Foreign Keys:** See primary keys, column types, nullability, and foreign key references at a glance.
+- 💾 **Multi-Format Exports:** Instant SQL `INSERT`s (`Ctrl + I`), Markdown (`Ctrl + M`), CSV (`Ctrl + E`), and JSON (`Ctrl + J`).
+- 📜 **Query History:** Cycle through your last 20 queries with `Ctrl + ↑` and `Ctrl + ↓`.
+- 🎨 **Clean Cyberpunk Aesthetic:** Fast, high-contrast, zero-flicker terminal interface.
+
+---
+
+## 📦 Installation & Quick Start
+
+### Via pip
+
+```bash
+pip install ghostbase-cli
+```
+
+### From Source
+
+```bash
+git clone https://github.com/4yk5/GhostBase.git
+cd GhostBase
+pip install -r requirements.txt
+```
+
+---
+
+## 💻 How to Use
+
+### 1. Auto-connect to current project (`.env`)
+```bash
+# Automatically finds DATABASE_URL or DB_HOST in your current directory's .env
+ghostbase
+```
+
+### 2. Connect to SQLite
+```bash
+ghostbase path/to/database.db
+```
+
+### 3. Connect to PostgreSQL
+```bash
+ghostbase postgresql://user:password@localhost:5432/my_database
+```
+
+### 4. Connect to MySQL
+```bash
+ghostbase mysql://user:password@localhost:3306/my_database
+```
+
+### 5. Launch in Safe / Read-Only Mode
+```bash
+ghostbase postgresql://prod-db:5432/main --read-only
+```
+
+---
+
+## ⌨️ Keyboard Shortcuts
+
+| Shortcut | Description |
+| :--- | :--- |
+| `Ctrl + R` | **Execute SQL Query** (runs the query with safety validation) |
+| `Ctrl + P` | **1-Key EXPLAIN** (instant query execution plan and performance inspector) |
+| `Ctrl + B` | **Beautify SQL** (auto-formats, capitalizes keywords and indents clauses) |
+| `Ctrl + S` | **Toggle Safe Mode** (enable/disable destructive query protection) |
+| `Ctrl + N` | **New Query** (clears editor for a clean query) |
+| `Ctrl + F` | **Find Table** (focuses table search filter) |
+| `Ctrl + I` | **Export to SQL INSERTs** (generates executable `INSERT INTO` statements) |
+| `Ctrl + M` | **Export to Markdown** (GitHub / Jira / Notion ready table) |
+| `Ctrl + E` | **Export to CSV** (exports current table/query to CSV) |
+| `Ctrl + J` | **Export to JSON** (exports current table/query to JSON) |
+| `Ctrl + ↑` / `Ctrl + ↓` | **Query History** (cycle through previous queries) |
+| `Tab` / `Shift + Tab` | Navigate between explorer, search, editor, and data table |
+| `Ctrl + Q` | **Quit GhostBase** |
+
+---
+
+## 📬 Contact & Inquiries
+
+For partnerships, feature requests, or business inquiries:  
+📧 **[contact.4yk5@proton.me](mailto:contact.4yk5@proton.me)**
+
+---
+
+## 📄 License
+
+Released under the [MIT License](LICENSE).

ghostbase_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+app.py,sha256=6ld3qVBcpzGV8TN_asTxCWN4Yky3WTHL9ygqPi1eUj0,26752
+db_engine.py,sha256=ZTFwBn1ALGdZCqHijMm6HGc_Q9r1AgJn0d5sTdl4BUo,15774
+exporter.py,sha256=LWP5aH5T1hfgv1S-3cUzznQe4QuWt5cPwl_A5P6h_PA,2200
+main.py,sha256=Jds9cR2JS6hI4ZAHFyKcSCdqdojXybNI0ra7xMO_tS4,3949
+ghostbase_cli-0.1.0.dist-info/licenses/LICENSE,sha256=bRo5mnl7qxXILhxEc0K1gp_mlFDLvbZN6ZxQyAyPtMQ,1061
+ghostbase_cli-0.1.0.dist-info/METADATA,sha256=b6pkOhxKF6Fbh3tz6_58lYw2sYPnqONOmDA3IFPfqMQ,7346
+ghostbase_cli-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+ghostbase_cli-0.1.0.dist-info/entry_points.txt,sha256=MU-O2U7GG76Irs1c7hQmlG8YkQ40sOlPnpU0RKI8Kzc,40
+ghostbase_cli-0.1.0.dist-info/top_level.txt,sha256=AUwoRm-j29Gjq6eOpfILcrpBYifVS0Pi2JCHvoi4Ufg,28
+ghostbase_cli-0.1.0.dist-info/RECORD,,

ghostbase_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ghostbase_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ghostbase = main:main

ghostbase_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 4yk5
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ghostbase_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+app
+db_engine
+exporter
+main