kctl-pg 0.7.2__py3-none-any.whl

kctl_pg/__init__.py

@@ -0,0 +1,3 @@
+"""Kodemeio PostgreSQL CLI."""
+
+__version__ = "0.1.0"

kctl_pg/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m kctl_pg."""
+
+from kctl_pg.cli import _run
+
+_run()

kctl_pg/cli.py

@@ -0,0 +1,162 @@
+"""Main CLI entry point for kctl-pg."""
+
+from __future__ import annotations
+
+
+from typing import Annotated
+
+import typer
+from kctl_lib import handle_cli_error
+
+from kctl_pg import __version__
+from kctl_pg.commands.activity import app as activity_app
+from kctl_pg.commands.automation import app as automation_app
+from kctl_pg.commands.backup import app as backup_app
+from kctl_pg.commands.config_cmd import app as config_app
+from kctl_pg.commands.dashboard import app as dashboard_app
+from kctl_pg.commands.db import app as db_app
+from kctl_pg.commands.dr import app as dr_app
+from kctl_pg.commands.extensions import app as extensions_app
+from kctl_pg.commands.health import app as health_app
+from kctl_pg.commands.indexes import app as indexes_app
+from kctl_pg.commands.lint import app as lint_app
+from kctl_pg.commands.maintenance import app as maintenance_app
+from kctl_pg.commands.performance import app as performance_app
+from kctl_pg.commands.pg_config import app as pg_config_app
+from kctl_pg.commands.pgbouncer import app as pgbouncer_app
+from kctl_pg.commands.pipeline import app as pipeline_app
+from kctl_pg.commands.query import app as query_app
+from kctl_pg.commands.replication import app as replication_app
+from kctl_pg.commands.schemas import app as schemas_app
+from kctl_pg.commands.security import app as security_app
+from kctl_pg.commands.stats import app as stats_app
+from kctl_pg.commands.tables import app as tables_app
+from kctl_pg.commands.users import app as users_app
+from kctl_pg.core.callbacks import AppContext
+from kctl_pg.core.exceptions import KctlError
+from kctl_pg.commands.skill_cmd import app as skill_app
+from kctl_pg.commands.doctor_cmd import app as doctor_app
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-pg {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-pg",
+    help="Kodemeio PostgreSQL CLI - manage PostgreSQL servers via SSH tunnel.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    host: Annotated[str | None, typer.Option("--host", "-H", help="PostgreSQL host override")] = None,
+    port: Annotated[int | None, typer.Option("--port", help="PostgreSQL port override")] = None,
+    user: Annotated[str | None, typer.Option("--user", "-U", help="PostgreSQL user override")] = None,
+    password: Annotated[str | None, typer.Option("--password", help="PostgreSQL password override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio PostgreSQL CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        host_override=host,
+        port_override=port,
+        user_override=user,
+        password_override=password,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-pg", __version__)
+
+
+# Register all command groups
+app.add_typer(config_app, name="config")
+app.add_typer(db_app, name="db")
+app.add_typer(users_app, name="users")
+app.add_typer(health_app, name="health")
+app.add_typer(dashboard_app, name="dashboard")
+app.add_typer(query_app, name="query")
+app.add_typer(activity_app, name="activity")
+app.add_typer(backup_app, name="backup")
+app.add_typer(extensions_app, name="extensions")
+app.add_typer(maintenance_app, name="maintenance")
+app.add_typer(performance_app, name="performance")
+app.add_typer(pg_config_app, name="pg-config")
+app.add_typer(replication_app, name="replication")
+app.add_typer(security_app, name="security")
+app.add_typer(stats_app, name="stats")
+app.add_typer(tables_app, name="tables")
+app.add_typer(indexes_app, name="indexes")
+app.add_typer(schemas_app, name="schemas")
+app.add_typer(pgbouncer_app, name="pgbouncer")
+app.add_typer(lint_app, name="lint")
+app.add_typer(automation_app, name="automation")
+app.add_typer(dr_app, name="dr")
+app.add_typer(pipeline_app, name="pipeline")
+app.add_typer(skill_app, name="skill", hidden=True)
+app.add_typer(doctor_app, name="doctor")
+add_tui_command(app, service_key="pg", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-pg."""
+    actx = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-pg", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-pg")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-pg", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-pg", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_pg/commands/activity.py

@@ -0,0 +1,176 @@
+"""Connection and activity monitoring commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_pg.core.callbacks import AppContext
+
+app = typer.Typer(help="Monitor connections and activity.")
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    database: Annotated[str | None, typer.Option("--db", "-d", help="Filter by database")] = None,
+    state: Annotated[
+        str | None, typer.Option("--state", help="Filter by state (active, idle, idle in transaction)")
+    ] = None,
+) -> None:
+    """List active connections."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    sql = """
+        SELECT
+            pid,
+            datname AS database,
+            usename AS user,
+            client_addr,
+            state,
+            now() - backend_start AS backend_age,
+            now() - query_start AS query_duration,
+            left(query, 100) AS query
+        FROM pg_stat_activity
+        WHERE backend_type = 'client backend'
+    """
+    params: list = []
+
+    if database:
+        sql += " AND datname = %s"
+        params.append(database)
+    if state:
+        sql += " AND state = %s"
+        params.append(state)
+
+    sql += " ORDER BY backend_start"
+
+    rows_data = c.fetchall(sql, tuple(params) if params else None)
+
+    rows = [
+        [
+            str(r["pid"]),
+            r["database"] or "-",
+            r["user"] or "-",
+            str(r["client_addr"]) if r["client_addr"] else "-",
+            r["state"] or "-",
+            str(r["query_duration"]).split(".")[0] if r["query_duration"] else "-",
+            r["query"][:60] if r["query"] else "-",
+        ]
+        for r in rows_data
+    ]
+
+    out.table(
+        f"Connections ({len(rows_data)})",
+        [
+            ("PID", ""),
+            ("Database", "cyan"),
+            ("User", ""),
+            ("Client", ""),
+            ("State", ""),
+            ("Duration", "yellow"),
+            ("Query", "dim"),
+        ],
+        rows,
+        data_for_json=rows_data,
+    )
+
+
+@app.command()
+def kill(
+    ctx: typer.Context,
+    pid: Annotated[int, typer.Argument(help="Backend PID to terminate")],
+    force: Annotated[
+        bool, typer.Option("--force", help="Use pg_terminate_backend (instead of pg_cancel_backend)")
+    ] = False,
+) -> None:
+    """Cancel or terminate a backend process."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    if force:
+        result = c.fetchval("SELECT pg_terminate_backend(%s)", (pid,))
+        action = "Terminated"
+    else:
+        result = c.fetchval("SELECT pg_cancel_backend(%s)", (pid,))
+        action = "Cancelled"
+
+    if result:
+        out.success(f"{action} backend PID {pid}")
+    else:
+        out.error(f"Failed to {action.lower()} PID {pid} (process may not exist)")
+
+
+@app.command()
+def locks(
+    ctx: typer.Context,
+    database: Annotated[str | None, typer.Option("--db", "-d", help="Filter by database")] = None,
+) -> None:
+    """Show lock contention (blocked queries waiting for locks)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    c = actx.client
+
+    rows_data = c.fetchall("""
+        SELECT
+            blocked.pid AS blocked_pid,
+            blocked.usename AS blocked_user,
+            blocked_activity.query AS blocked_query,
+            blocking.pid AS blocking_pid,
+            blocking.usename AS blocking_user,
+            blocking_activity.query AS blocking_query,
+            blocked.datname AS database
+        FROM pg_catalog.pg_locks blocked
+        JOIN pg_catalog.pg_stat_activity blocked_activity ON blocked_activity.pid = blocked.pid
+        JOIN pg_catalog.pg_locks blocking ON blocking.locktype = blocked.locktype
+            AND blocking.database IS NOT DISTINCT FROM blocked.database
+            AND blocking.relation IS NOT DISTINCT FROM blocked.relation
+            AND blocking.page IS NOT DISTINCT FROM blocked.page
+            AND blocking.tuple IS NOT DISTINCT FROM blocked.tuple
+            AND blocking.virtualxid IS NOT DISTINCT FROM blocked.virtualxid
+            AND blocking.transactionid IS NOT DISTINCT FROM blocked.transactionid
+            AND blocking.classid IS NOT DISTINCT FROM blocked.classid
+            AND blocking.objid IS NOT DISTINCT FROM blocked.objid
+            AND blocking.objsubid IS NOT DISTINCT FROM blocked.objsubid
+            AND blocking.pid != blocked.pid
+        JOIN pg_catalog.pg_stat_activity blocking_activity ON blocking_activity.pid = blocking.pid
+        JOIN pg_stat_activity blocked_sa ON blocked_sa.pid = blocked.pid
+        WHERE NOT blocked.granted
+    """)
+
+    if database:
+        rows_data = [r for r in rows_data if r["database"] == database]
+
+    if not rows_data:
+        out.success("No lock contention detected")
+        return
+
+    rows = [
+        [
+            str(r["blocked_pid"]),
+            r["blocked_user"] or "-",
+            (r["blocked_query"] or "-")[:50],
+            str(r["blocking_pid"]),
+            r["blocking_user"] or "-",
+            (r["blocking_query"] or "-")[:50],
+        ]
+        for r in rows_data
+    ]
+
+    out.table(
+        f"Lock Contention ({len(rows_data)})",
+        [
+            ("Blocked PID", "red"),
+            ("User", ""),
+            ("Blocked Query", "dim"),
+            ("Blocking PID", "yellow"),
+            ("User", ""),
+            ("Blocking Query", "dim"),
+        ],
+        rows,
+        data_for_json=rows_data,
+    )