morphy-cli 0.5.0__py3-none-any.whl

morphy_cli/control.py

@@ -0,0 +1,323 @@
+"""Client for Supabase control-plane RPCs and PostgREST tables."""
+
+from typing import Any, Optional
+import uuid
+import httpx
+
+from .auth import AuthManager, AuthError
+
+
+class ControlPlaneError(Exception):
+    """Error during control plane operations."""
+    pass
+
+
+class ControlClient:
+    """Interacts with Supabase PostgREST endpoints and RPCs."""
+
+    def __init__(self, auth_manager: AuthManager):
+        self.auth = auth_manager
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[dict[str, Any]] = None,
+        json_body: Optional[Any] = None,
+    ) -> Any:
+        token = self.auth.get_valid_token()
+        headers = {
+            "apikey": self.auth.supabase_key,
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+            "Prefer": "return=representation",
+        }
+        url = f"{self.auth.supabase_url}{path}"
+
+        try:
+            with httpx.Client(timeout=15.0) as client:
+                resp = client.request(method, url, headers=headers, params=params, json=json_body)
+        except httpx.HTTPError as exc:
+            raise ControlPlaneError(f"Network error accessing control plane: {exc}")
+
+        if resp.is_error:
+            try:
+                err = resp.json()
+                detail = err.get("message") or err.get("detail") or resp.text
+            except Exception:
+                detail = resp.text
+            raise ControlPlaneError(f"Control plane error ({resp.status_code}): {detail}")
+
+        if resp.status_code == 204 or not resp.content:
+            return None
+        return resp.json()
+
+    # --- Profile ---
+
+    def get_profile(self) -> Optional[dict[str, Any]]:
+        status = self.auth.status()
+        user_id = status.get("user_id")
+        if not user_id:
+            res = self._request("GET", "/rest/v1/profiles?select=*")
+            return res[0] if res else None
+
+        res = self._request("GET", f"/rest/v1/profiles?id=eq.{user_id}&select=*")
+        return res[0] if res else None
+
+    def claim_profile(self, username: str, display_name: str) -> None:
+        self._request(
+            "POST",
+            "/rest/v1/rpc/claim_profile",
+            json_body={"handle": username.strip().lower(), "full_name": display_name.strip()},
+        )
+
+    def update_profile(self, display_name: str, avatar_path: Optional[str] = None) -> None:
+        try:
+            self._request(
+                "POST",
+                "/rest/v1/rpc/update_profile",
+                json_body={"full_name": display_name.strip(), "avatar": avatar_path},
+            )
+            return
+        except Exception:
+            pass
+
+        profile = self.get_profile()
+        user_id = profile.get("id") if profile else None
+        if not user_id:
+            status = self.auth.status()
+            user_id = status.get("user_id")
+        if not user_id:
+            raise ControlPlaneError("Must be authenticated with a claimed profile to edit.")
+        self._request(
+            "PATCH",
+            f"/rest/v1/profiles?id=eq.{user_id}",
+            json_body={"display_name": display_name.strip()},
+        )
+
+    # --- Organizations ---
+
+    def list_organizations(self) -> list[dict[str, Any]]:
+        return self._request("GET", "/rest/v1/organizations?select=*&order=name.asc") or []
+
+    def create_organization(self, name: str) -> str:
+        res = self._request(
+            "POST",
+            "/rest/v1/rpc/create_workspace",
+            json_body={"title": name.strip()},
+        )
+        return str(res)
+
+    # --- Target Databases ---
+
+    def list_databases(self, org_id: Optional[str] = None) -> list[dict[str, Any]]:
+        query = "/rest/v1/target_databases?select=*&order=name.asc"
+        if org_id:
+            query += f"&org_id=eq.{org_id}"
+        return self._request("GET", query) or []
+
+    def register_database(self, org_id: str, name: str, dialect: str) -> str:
+        res = self._request(
+            "POST",
+            "/rest/v1/rpc/register_database",
+            json_body={"o": org_id, "title": name.strip(), "engine": dialect.strip().lower()},
+        )
+        return str(res)
+
+    # --- Members & Roles ---
+
+    def list_roles(self, org_id: str) -> list[dict[str, Any]]:
+        return self._request("GET", f"/rest/v1/roles?org_id=eq.{org_id}&select=*") or []
+
+    def list_members(self, org_id: str) -> list[dict[str, Any]]:
+        return self._request(
+            "POST",
+            "/rest/v1/rpc/org_people",
+            json_body={"o": org_id},
+        ) or []
+
+    def set_member_role(self, org_id: str, user_id: str, role_id: str) -> None:
+        self._request(
+            "POST",
+            "/rest/v1/rpc/set_member_role",
+            json_body={"o": org_id, "person": user_id, "r": role_id},
+        )
+
+    # --- Invitations ---
+
+    def list_invitations(self) -> list[dict[str, Any]]:
+        return self._request("GET", "/rest/v1/invitations?select=*&order=created_at.desc") or []
+
+    def invite_person(self, org_id: str, user_id: str, role_id: str) -> None:
+        self._request(
+            "POST",
+            "/rest/v1/rpc/invite_person",
+            json_body={"o": org_id, "person": user_id, "r": role_id},
+        )
+
+    def accept_invitation(self, invitation_id: str) -> None:
+        self._request(
+            "POST",
+            "/rest/v1/rpc/accept_invitation",
+            json_body={"inv": invitation_id},
+        )
+
+    def withdraw_invitation(self, invitation_id: str) -> None:
+        try:
+            self._request(
+                "POST",
+                "/rest/v1/rpc/revoke_invitation",
+                json_body={"inv": invitation_id},
+            )
+            return
+        except Exception:
+            pass
+
+        self._request(
+            "DELETE",
+            f"/rest/v1/invitations?id=eq.{invitation_id}",
+        )
+
+    def find_people(self, prefix: str) -> list[dict[str, Any]]:
+        return self._request(
+            "POST",
+            "/rest/v1/rpc/find_people",
+            json_body={"prefix": prefix.strip().lower()},
+        ) or []
+
+    # --- Dashboards & Panels (004) ---
+
+    def list_dashboards(
+        self, org_id: Optional[str] = None, database_id: Optional[str] = None
+    ) -> list[dict[str, Any]]:
+        query = "/rest/v1/dashboards?select=*,dashboard_panels(*)&order=updated_at.desc"
+        if org_id:
+            query += f"&org_id=eq.{org_id}"
+        if database_id:
+            query += f"&database_id=eq.{database_id}"
+        return self._request("GET", query) or []
+
+    def get_dashboard(self, dashboard_id: str) -> Optional[dict[str, Any]]:
+        res = self._request(
+            "GET",
+            f"/rest/v1/dashboards?id=eq.{dashboard_id}&select=*,dashboard_panels(*)",
+        )
+        return res[0] if res else None
+
+    def create_dashboard(
+        self, org_id: str, database_id: str, title: str, shared: bool = False
+    ) -> str:
+        res = self._request(
+            "POST",
+            "/rest/v1/dashboards",
+            json_body={
+                "org_id": org_id,
+                "database_id": database_id,
+                "title": title.strip(),
+                "shared": shared,
+            },
+        )
+        if isinstance(res, list) and res:
+            return str(res[0].get("id"))
+        return str(res)
+
+    def add_dashboard_panel(
+        self, dashboard_id: str, database_id: str, query_id: str, position: int = 0
+    ) -> None:
+        self._request(
+            "POST",
+            "/rest/v1/dashboard_panels",
+            json_body={
+                "dashboard_id": dashboard_id,
+                "database_id": database_id,
+                "query_id": query_id,
+                "position": position,
+            },
+        )
+
+    def delete_dashboard(self, dashboard_id: str) -> None:
+        self._request("DELETE", f"/rest/v1/dashboards?id=eq.{dashboard_id}")
+
+    # --- Cloud Saved Queries (003) ---
+
+    def list_saved_queries(
+        self, org_id: Optional[str] = None, database_id: Optional[str] = None
+    ) -> list[dict[str, Any]]:
+        query = "/rest/v1/saved_queries?select=*&order=updated_at.desc"
+        if org_id:
+            query += f"&org_id=eq.{org_id}"
+        if database_id:
+            query += f"&database_id=eq.{database_id}"
+        return self._request("GET", query) or []
+
+    def create_saved_query(
+        self, org_id: str, database_id: str, title: str, sql_text: str, shared: bool = False
+    ) -> str:
+        res = self._request(
+            "POST",
+            "/rest/v1/saved_queries",
+            json_body={
+                "org_id": org_id,
+                "database_id": database_id,
+                "title": title.strip(),
+                "sql_text": sql_text.strip(),
+                "shared": shared,
+            },
+        )
+        if isinstance(res, list) and res:
+            return str(res[0].get("id"))
+        return str(res)
+
+    def delete_saved_query(self, query_id: str) -> None:
+        self._request("DELETE", f"/rest/v1/saved_queries?id=eq.{query_id}")
+
+    # --- Permissions & Access Policy ---
+
+    def save_permission(
+        self,
+        org_id: str,
+        database_id: str,
+        role_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        level: str = "QUERY_ONLY",
+        cols: Optional[dict[str, list[str]]] = None,
+        rules: Optional[list[dict[str, Any]]] = None,
+    ) -> None:
+        self._request(
+            "POST",
+            "/rest/v1/rpc/save_permission",
+            json_body={
+                "o": org_id,
+                "d": database_id,
+                "r": role_id,
+                "person": user_id,
+                "level": level,
+                "cols": cols or {},
+                "rules": rules or [],
+            },
+        )
+
+    def revoke_permission(
+        self,
+        org_id: str,
+        database_id: str,
+        role_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> None:
+        self.save_permission(
+            org_id=org_id,
+            database_id=database_id,
+            role_id=role_id,
+            user_id=user_id,
+            level="NONE",
+            cols={},
+            rules=[],
+        )
+
+    def effective_permission(self, database_id: str) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            "/rest/v1/rpc/effective_permission",
+            json_body={"d": database_id},
+        ) or {"mode": "NONE", "table_columns": {}, "row_rules": []}
+

morphy_cli/formatting.py

@@ -0,0 +1,143 @@
+"""Result formatting for the MORPHY terminal."""
+
+import csv
+import io
+import json
+from typing import Any, Sequence
+
+
+def format_table(columns: list[str], rows: list[list], row_count: int, elapsed_ms: float) -> str:
+    """Format query results as a readable aligned table."""
+    if not columns:
+        return f"(empty result · {elapsed_ms} ms)"
+
+    # Convert values to display strings, respecting NULLs.
+    str_rows = []
+    for row in rows:
+        str_rows.append(["\u2205" if v is None else str(v) for v in row])
+
+    # Compute column widths.
+    widths = [len(c) for c in columns]
+    for row in str_rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(cell))
+
+    # Cap each column at 48 characters for readability.
+    widths = [min(w, 48) for w in widths]
+
+    def truncate(text: str, width: int) -> str:
+        return text if len(text) <= width else text[: width - 1] + "\u2026"
+
+    lines = []
+    header = " \u2502 ".join(truncate(c, w).ljust(w) for c, w in zip(columns, widths))
+    lines.append(header)
+    lines.append("\u2500" * len(header))
+    for row in str_rows:
+        line = " \u2502 ".join(truncate(cell, w).ljust(w) for cell, w in zip(row, widths))
+        lines.append(line)
+
+    capped = " (capped)" if row_count >= 1000 else ""
+    lines.append(f"\n{row_count} row{'s' if row_count != 1 else ''}{capped} · {elapsed_ms} ms")
+    return "\n".join(lines)
+
+
+def format_csv(columns: list[str], rows: list[list]) -> str:
+    """Export query results as a standard RFC-4180 CSV string."""
+    output = io.StringIO()
+    writer = csv.writer(output, lineterminator="\n")
+    writer.writerow(columns)
+    for row in rows:
+        writer.writerow(["" if cell is None else cell for cell in row])
+    return output.getvalue()
+
+
+def format_records_table(headers: list[str], items: list[dict[str, Any]], keys: list[str]) -> str:
+    """Format an arbitrary list of objects as an aligned CLI table."""
+    if not items:
+        return "(none)"
+    rows = [[str(item.get(k, "")) for k in keys] for item in items]
+    return format_table(headers, rows, len(items), 0.0).split("\n\n")[0]
+
+
+def format_schema(tables: dict) -> str:
+    """Format schema metadata as an indented tree."""
+    if not tables:
+        return "(no permitted tables)"
+    lines = []
+    for table, columns in tables.items():
+        lines.append(f"  {table}")
+        if isinstance(columns, dict):
+            for col, dtype in columns.items():
+                lines.append(f"    {col}: {dtype}")
+        elif isinstance(columns, list):
+            for col in columns:
+                lines.append(f"    {col}")
+    return "\n".join(lines)
+
+
+def format_examples(examples: list[str]) -> str:
+    """Format example question titles."""
+    if not examples:
+        return "(no examples available)"
+    return "\n".join(f"  • {title}" for title in examples)
+
+
+def format_generation(gen: dict) -> str:
+    """Format a generation response showing SQL and metadata."""
+    lines = []
+    lines.append(gen["sql"])
+    meta = []
+    if gen.get("provider"):
+        meta.append(gen["provider"])
+    if gen.get("attempts"):
+        meta.append(f"{gen['attempts']} attempt{'s' if gen['attempts'] != 1 else ''}")
+    if gen.get("cache"):
+        meta.append(f"cache {gen['cache']}")
+    if meta:
+        lines.append(f"({' · '.join(meta)})")
+    return "\n".join(lines)
+
+
+def format_json(data: Any) -> str:
+    """Pretty-print arbitrary data as JSON."""
+    return json.dumps(data, indent=2, default=str)
+
+
+def format_banner(
+    *,
+    version: str = "0.5.0",
+    engine_url: str = "http://127.0.0.1:8000",
+    database: Any = None,
+    user_email: Any = None,
+    org_name: Any = None,
+) -> str:
+    """Render the stylish Claude-Code-inspired ASCII brand banner."""
+    ORANGE = "\033[38;5;208m"
+    DIM = "\033[90m"
+    BOLD = "\033[1m"
+    GREEN = "\033[92m"
+    RESET = "\033[0m"
+    WHITE = "\033[97m"
+    CYAN = "\033[96m"
+
+    logo = f"""
+{ORANGE}{BOLD}  ███╗   ███╗ ██████╗ ██████╗ ██████╗ ██╗  ██╗██╗   ██╗
+  ████╗ ████║██╔═══██╗██╔══██╗██╔══██╗██║  ██║╚██╗ ██╔╝
+  ██╔████╔██║██║   ██║██████╔╝██████╔╝███████║ ╚████╔╝ 
+  ██║╚██╔╝██║██║   ██║██╔══██╗██╔═══╝ ██╔══██║  ╚██╔╝  
+  ██║ ╚═╝ ██║╚██████╔╝██║  ██║██║     ██║  ██║   ██║   
+  ╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═╝     ╚═╝  ╚═╝   ╚═╝   {RESET}
+  {DIM}Governed Natural-Language Database Terminal{RESET}  {CYAN}v{version}{RESET}"""
+
+    lines = [logo]
+    if database:
+        db_label = f"{org_name}/{database}" if org_name else str(database)
+        lines.append(f"  {GREEN}●{RESET} Database:  {WHITE}{BOLD}{db_label}{RESET} {DIM}(live query mode){RESET}")
+        if user_email:
+            lines.append(f"  {GREEN}●{RESET} User:      {WHITE}{BOLD}{user_email}{RESET}")
+    else:
+        lines.append(f"  {GREEN}●{RESET} Workspace: {WHITE}{BOLD}SAMPLE{RESET} {DIM}(synthetic commerce · APAC policy){RESET}")
+
+    lines.append(f"  {GREEN}●{RESET} Engine:    {WHITE}{BOLD}{engine_url}{RESET}")
+    lines.append(f"\n  {DIM}Type {CYAN}/help{DIM} for commands · {CYAN}Tab{DIM} to autocomplete · {CYAN}Ctrl+C{DIM} to clear · {CYAN}Ctrl+D{DIM} to exit{RESET}\n")
+    return "\n".join(lines)

morphy_cli/main.py

@@ -0,0 +1,113 @@
+"""MORPHY governed query terminal.
+
+Supports both interactive (REPL with prompt-toolkit) and noninteractive
+(--sql) modes. Install with ``python -m pip install -e ./cli``.
+"""
+
+import argparse
+import sys
+from uuid import UUID
+
+from .auth import AuthManager
+from .client import EngineError, MorphyClient
+from .formatting import format_csv, format_json, format_table
+
+import httpx
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="morphy",
+        description="MORPHY — governed natural-language database terminal",
+        epilog=(
+            "Examples:\n"
+            "  morphy                            Open the sample REPL\n"
+            "  morphy --database <UUID>          Query an organization database\n"
+            "  morphy --sql 'SELECT 1'           Run one query and exit\n"
+            "  morphy --sql 'SELECT 1' --json    Output results in JSON format\n"
+            "  morphy --sql 'SELECT 1' --csv     Output results in CSV format\n"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--url",
+        default="http://127.0.0.1:8000",
+        help="Engine base URL (default: http://127.0.0.1:8000)",
+    )
+    parser.add_argument(
+        "--sql",
+        metavar="QUERY",
+        help="Run one read-only SQL query and exit",
+    )
+    parser.add_argument(
+        "--database",
+        type=UUID,
+        metavar="UUID",
+        help="Query an organization database using saved session or MORPHY_ACCESS_TOKEN",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output noninteractive query results as JSON",
+    )
+    parser.add_argument(
+        "--csv",
+        action="store_true",
+        help="Output noninteractive query results as CSV",
+    )
+    args = parser.parse_args()
+
+    auth = AuthManager()
+    auth.restore_session()
+
+    try:
+        client = MorphyClient(
+            args.url,
+            args.database,
+            token=lambda: auth.get_valid_token(),
+        )
+    except SystemExit as exc:
+        parser.error(str(exc))
+
+    # Noninteractive mode: execute single SQL statement and exit
+    if args.sql:
+        try:
+            result = client.query(args.sql)
+            if args.json:
+                print(format_json(result))
+            elif args.csv:
+                print(format_csv(result["columns"], result["rows"]), end="")
+            else:
+                print(
+                    format_table(
+                        result["columns"],
+                        result["rows"],
+                        result["row_count"],
+                        result["elapsed_ms"],
+                    )
+                )
+        except EngineError as error:
+            print(f"Error: {error.detail}", file=sys.stderr)
+            if error.status_code >= 500:
+                sys.exit(2)
+            sys.exit(1)
+        except httpx.HTTPError as error:
+            print(f"Network error: {error}", file=sys.stderr)
+            sys.exit(2)
+        except KeyboardInterrupt:
+            print("\nCancelled.", file=sys.stderr)
+            sys.exit(130)
+        finally:
+            client.close()
+        return
+
+    # Interactive REPL mode
+    try:
+        from .shell import run_repl
+
+        run_repl(client, auth_manager=auth)
+    except KeyboardInterrupt:
+        print()
+        sys.exit(130)
+    finally:
+        client.close()

morphy_cli/queries.py

@@ -0,0 +1,75 @@
+"""Persistent saved queries manager for MORPHY CLI."""
+
+import json
+from pathlib import Path
+import time
+from typing import Any, Optional
+
+CONFIG_DIR = Path.home() / ".morphy"
+QUERIES_FILE = CONFIG_DIR / "queries.json"
+
+
+class QueryStore:
+    """Manages saved queries persisted in ~/.morphy/queries.json."""
+
+    def __init__(self, filepath: Optional[Path] = None):
+        self.filepath = filepath or QUERIES_FILE
+
+    def _load(self) -> dict[str, dict[str, Any]]:
+        if not self.filepath.is_file():
+            return {}
+        try:
+            data = json.loads(self.filepath.read_text(encoding="utf-8"))
+            return data if isinstance(data, dict) else {}
+        except Exception:
+            return {}
+
+    def _save(self, data: dict[str, dict[str, Any]]) -> None:
+        self.filepath.parent.mkdir(parents=True, exist_ok=True)
+        self.filepath.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    def save(
+        self,
+        name: str,
+        sql: str,
+        database_id: Optional[str] = None,
+        description: str = "",
+    ) -> dict[str, Any]:
+        """Save or update a query by name."""
+        clean_name = name.strip()
+        data = self._load()
+        record = {
+            "name": clean_name,
+            "sql": sql.strip(),
+            "database_id": database_id or "sample",
+            "description": description.strip(),
+            "created_at": time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()),
+        }
+        data[clean_name] = record
+        self._save(data)
+        return record
+
+    def list(self, database_id: Optional[str] = None) -> list[dict[str, Any]]:
+        """List all saved queries, optionally filtered by database."""
+        data = self._load()
+        records = list(data.values())
+        if database_id:
+            records = [r for r in records if r.get("database_id") in (database_id, "sample")]
+        records.sort(key=lambda r: r.get("name", ""))
+        return records
+
+    def get(self, name: str) -> Optional[dict[str, Any]]:
+        """Retrieve a saved query by name."""
+        data = self._load()
+        return data.get(name.strip())
+
+    def delete(self, name: str) -> bool:
+        """Delete a saved query by name. Returns True if found and deleted."""
+        clean_name = name.strip()
+        data = self._load()
+        if clean_name in data:
+            del data[clean_name]
+            self._save(data)
+            return True
+        return False
+