PyPI - loony - Versions diffs - 0.1.2__tar.gz - Mend

loony 0.1.2__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

loony-0.1.2/.gitignore +10 -0
loony-0.1.2/PKG-INFO +10 -0
loony-0.1.2/loony/__init__.py +1 -0
loony-0.1.2/loony/api.py +56 -0
loony-0.1.2/loony/auth.py +87 -0
loony-0.1.2/loony/cli.py +280 -0
loony-0.1.2/loony/config.py +77 -0
loony-0.1.2/loony/init.py +297 -0
loony-0.1.2/loony/skills.py +116 -0
loony-0.1.2/loony/templates/claude/skills/loony-build-pipeline/SKILL.md +174 -0
loony-0.1.2/loony/templates/claude/skills/loony-test-validate/SKILL.md +85 -0
loony-0.1.2/loony/templates/codex/AGENTS.md +1 -0
loony-0.1.2/loony/templates/cursor/loony.mdc +6 -0
loony-0.1.2/loony/templates/shared/loony.md +215 -0
loony-0.1.2/pyproject.toml +22 -0

loony-0.1.2/.gitignore ADDED Viewed

@@ -0,0 +1,10 @@
+loony-ref/
+.venv/
+__pycache__/
+*.pyc
+.env
+.env.local
+*.egg-info/
+dist/
+build/
+.dlt/

loony-0.1.2/PKG-INFO ADDED Viewed

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: loony
+Version: 0.1.2
+Summary: CLI for loony — governed data services for agents
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=14.0
+Requires-Dist: typer>=0.15
+Requires-Dist: workos>=5.46

loony-0.1.2/loony/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ __version__ = "0.1.1"

loony-0.1.2/loony/api.py ADDED Viewed

@@ -0,0 +1,56 @@
+"""HTTP client for talking to the control plane."""
+import httpx
+from . import config
+def _get_client(env: str | None = None, timeout: int = 30) -> tuple[httpx.Client, dict]:
+    env_config = config.get_env_config(env)
+    endpoint = env_config.get("endpoint")
+    token = env_config.get("access_token")
+    if not endpoint:
+        raise ValueError(f"No endpoint configured for environment '{config.get_current_env()}'")
+    if not token:
+        raise ValueError("Not logged in. Run 'loony login' first.")
+    client = httpx.Client(
+        base_url=endpoint,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=timeout,
+    )
+    return client, env_config
+def me(env: str | None = None) -> dict:
+    client, _ = _get_client(env)
+    resp = client.get("/api/v1/me")
+    resp.raise_for_status()
+    return resp.json()
+def health(env: str | None = None) -> dict:
+    env_config = config.get_env_config(env)
+    endpoint = env_config.get("endpoint")
+    if not endpoint:
+        raise ValueError(f"No endpoint configured for environment '{config.get_current_env()}'")
+    resp = httpx.get(f"{endpoint}/healthz", timeout=10)
+    resp.raise_for_status()
+    return resp.json()
+def deploy(name: str, payload: dict, env: str | None = None) -> dict:
+    # Large script uploads can take well over 30s — use a generous timeout.
+    client, _ = _get_client(env, timeout=300)
+    resp = client.post(f"/api/v1/services/{name}/deploy", json=payload)
+    resp.raise_for_status()
+    return resp.json()
+def submit_feedback(payload: dict, env: str | None = None) -> dict:
+    client, _ = _get_client(env)
+    resp = client.post("/api/v1/feedback", json=payload)
+    resp.raise_for_status()
+    return resp.json()

loony-0.1.2/loony/auth.py ADDED Viewed

@@ -0,0 +1,87 @@
+"""WorkOS browser-redirect login flow.
+The CLI handles the browser redirect and captures the auth code.
+The control plane exchanges the code for tokens (it has the API key).
+"""
+import http.server
+import urllib.parse
+import webbrowser
+import httpx
+from . import config
+REDIRECT_URI = "http://localhost:9876/callback"
+def login(env: str | None = None):
+    """Open browser for WorkOS login, send code to control plane, save credentials."""
+    env = env or config.get_current_env()
+    env_config = config.get_env_config(env)
+    endpoint = env_config.get("endpoint")
+    if not endpoint:
+        raise ValueError(f"No endpoint configured for environment '{env}'")
+    # Step 1: Get auth URL from control plane
+    resp = httpx.get(f"{endpoint}/auth/url", params={"redirect_uri": REDIRECT_URI}, timeout=10)
+    resp.raise_for_status()
+    auth_url = resp.json()["url"]
+    # Step 2: Open browser + capture callback code
+    result = {}
+    class CallbackHandler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):
+            query = urllib.parse.urlparse(self.path).query
+            params = urllib.parse.parse_qs(query)
+            if "code" in params:
+                result["code"] = params["code"][0]
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html")
+                self.end_headers()
+                self.wfile.write(
+                    b"<html><body style='font-family:system-ui;text-align:center;padding:60px'>"
+                    b"<h1>Logged in!</h1><p>You can close this tab.</p></body></html>"
+                )
+            else:
+                error = params.get("error", ["unknown"])[0]
+                result["error"] = error
+                self.send_response(400)
+                self.send_header("Content-Type", "text/html")
+                self.end_headers()
+                self.wfile.write(f"<html><body>Error: {error}</body></html>".encode())
+        def log_message(self, format, *args):
+            pass
+    server = http.server.HTTPServer(("localhost", 9876), CallbackHandler)
+    webbrowser.open(auth_url)
+    server.handle_request()
+    server.server_close()
+    if "error" in result:
+        raise RuntimeError(f"Login failed: {result['error']}")
+    # Step 3: Send code to control plane for exchange
+    resp = httpx.post(
+        f"{endpoint}/auth/callback",
+        json={"code": result["code"], "redirect_uri": REDIRECT_URI},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    # Step 4: Save credentials
+    config.save_credentials(env, {
+        "user_id": data["user_id"],
+        "email": data["email"],
+        "first_name": data.get("first_name"),
+        "last_name": data.get("last_name"),
+        "access_token": data["access_token"],
+        "refresh_token": data.get("refresh_token"),
+    })
+    return data

loony-0.1.2/loony/cli.py ADDED Viewed

@@ -0,0 +1,280 @@
+"""Loony CLI — governed data services for agents."""
+from typing import Optional
+import typer
+from rich.console import Console
+from rich.table import Table
+from . import __version__, api, auth, config
+from .init import init_project
+from . import skills as skills_mod
+app = typer.Typer(
+    name="loony",
+    help="Governed data services for agents.",
+    no_args_is_help=True,
+)
+console = Console()
+@app.callback(invoke_without_command=True)
+def main(
+    version: bool = typer.Option(False, "--version", "-v", help="Show version"),
+):
+    if version:
+        console.print(f"loony {__version__}")
+        raise typer.Exit()
+@app.command()
+def init(
+    name: str = typer.Argument(..., help="Service name"),
+    agent: Optional[str] = typer.Option(None, "--agent", "-a", help="Agent type: claude, cursor, codex"),
+    update: bool = typer.Option(False, "--update", "-u", help="Update loony templates only, preserve user files"),
+):
+    """Scaffold a new pipeline project, or update loony templates."""
+    from pathlib import Path
+    result = init_project(name, agent=agent, project_dir=Path.cwd(), update=update)
+    if update:
+        console.print(f"\n[green]✓[/green] Updated loony templates for [bold]{result['name']}[/bold]\n")
+        if result["updated"]:
+            console.print("[bold]Updated:[/bold]")
+            for f in result["updated"]:
+                console.print(f"  [yellow]{f}[/yellow]")
+        else:
+            console.print("[dim]Everything up to date.[/dim]")
+    else:
+        console.print(f"\n[green]✓[/green] Created service [bold]{result['name']}[/bold]\n")
+        if result["created"]:
+            console.print("[bold]Core files:[/bold]")
+            for f in result["created"]:
+                console.print(f"  {f}")
+        if result["skipped"]:
+            console.print(f"\n[dim]Skipped (already exist): {', '.join(result['skipped'])}[/dim]")
+        console.print(f"\n[bold]Next steps:[/bold]")
+        console.print("  1. Edit schema.yaml — define your tables, columns, sync modes")
+        console.print("  2. Write scripts in scripts/ — dlt scripts that export run(conn)")
+        console.print("  3. Write transforms in transforms/ — SQL to clean and aggregate")
+        console.print("  4. Run [bold]loony test[/bold] to validate")
+        console.print("  5. Run [bold]loony deploy[/bold] to go live")
+@app.command()
+def login(
+    env: Optional[str] = typer.Option(None, "--env", "-e", help="Environment to login to"),
+):
+    """Authenticate with loony.dev via browser."""
+    env = env or config.get_current_env()
+    console.print(f"Logging into [bold]{env}[/bold]...")
+    console.print("Opening browser...")
+    try:
+        user = auth.login(env)
+        console.print(f"\n[green]✓[/green] Logged in as [bold]{user['email']}[/bold]")
+        console.print(f"  User ID: {user['user_id']}")
+        console.print(f"  Environment: {env}")
+    except Exception as e:
+        console.print(f"\n[red]✗[/red] Login failed: {e}")
+        raise typer.Exit(1)
+@app.command()
+def logout(
+    env: Optional[str] = typer.Option(None, "--env", "-e", help="Environment to logout from"),
+):
+    """Clear stored credentials."""
+    env = env or config.get_current_env()
+    config.clear_credentials(env)
+    console.print(f"[green]✓[/green] Logged out from [bold]{env}[/bold]")
+@app.command()
+def env(
+    name: Optional[str] = typer.Argument(None, help="Environment to switch to"),
+):
+    """Show or switch the current environment."""
+    if name:
+        config.set_current_env(name)
+        console.print(f"[green]✓[/green] Switched to [bold]{name}[/bold]")
+    else:
+        current = config.get_current_env()
+        cfg = config.load()
+        envs = cfg.get("environments", {})
+        table = Table(title="Environments")
+        table.add_column("Name")
+        table.add_column("Endpoint")
+        table.add_column("User")
+        table.add_column("Active")
+        for env_name in set(config.DEFAULTS.keys()) | set(envs.keys()):
+            env_config = config.get_env_config(env_name)
+            endpoint = env_config.get("endpoint", "")
+            email = env_config.get("email", "")
+            active = "→" if env_name == current else ""
+            table.add_row(env_name, endpoint or "(not configured)", email or "(not logged in)", active)
+        console.print(table)
+@app.command()
+def status():
+    """Check connection to control plane and show user info."""
+    current = config.get_current_env()
+    env_config = config.get_env_config()
+    console.print(f"Environment: [bold]{current}[/bold]")
+    console.print(f"Endpoint: {env_config.get('endpoint', '(not configured)')}")
+    console.print()
+    # Health check
+    try:
+        h = api.health()
+        console.print(f"[green]✓[/green] Control plane: {h.get('status', 'unknown')}")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Control plane: {e}")
+        raise typer.Exit(1)
+    # Auth check
+    try:
+        user = api.me()
+        console.print(f"[green]✓[/green] Authenticated as: {user.get('email')}")
+        console.print(f"  User ID: {user.get('user_id')}")
+    except ValueError as e:
+        console.print(f"[yellow]⚠[/yellow] {e}")
+    except Exception as e:
+        console.print(f"[red]✗[/red] Auth failed: {e}")
+# ─── Feedback ──────────────────────────────────────────────────────────────────
+@app.command()
+def feedback(
+    message: str = typer.Argument(..., help="Describe the issue or suggestion"),
+    include_traceback: bool = typer.Option(True, "--traceback/--no-traceback", help="Include recent Python traceback if available"),
+):
+    """Submit feedback or report a bug. Creates a tracked issue with full context."""
+    import platform
+    import sys
+    import traceback as tb_mod
+    console.print("[dim]Gathering context...[/dim]")
+    payload = {
+        "message": message,
+        "cli_version": __version__,
+        "python_version": platform.python_version(),
+        "os": f"{platform.system()} {platform.release()}",
+        "environment": config.get_current_env(),
+    }
+    # Capture last traceback if available
+    if include_traceback:
+        last_tb = tb_mod.format_exc()
+        if last_tb and last_tb.strip() != "NoneType: None":
+            payload["traceback"] = last_tb
+    try:
+        result = api.submit_feedback(payload)
+        console.print(f"\n[green]✓[/green] Feedback submitted")
+        if result.get("issue_url"):
+            console.print(f"  Tracking: {result['issue_url']}")
+        if result.get("issue_number"):
+            console.print(f"  Issue #{result['issue_number']}")
+    except ValueError as e:
+        console.print(f"[red]✗[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]✗[/red] Failed to submit feedback: {e}")
+        raise typer.Exit(1)
+# ─── Skills ────────────────────────────────────────────────────────────────────
+skills_app = typer.Typer(help="Manage agent skills.")
+app.add_typer(skills_app, name="skills")
+@skills_app.callback(invoke_without_command=True)
+def skills_default(ctx: typer.Context):
+    """List available and installed skills."""
+    if ctx.invoked_subcommand is not None:
+        return
+    # Default: show list
+    _skills_list()
+@skills_app.command("list")
+def skills_list():
+    """List available and installed skills."""
+    _skills_list()
+def _skills_list():
+    from pathlib import Path
+    result = skills_mod.list_skills(Path.cwd())
+    table = Table(title="Skills")
+    table.add_column("Name")
+    table.add_column("Description")
+    table.add_column("Status")
+    for name, desc in result["available"].items():
+        if name in result["installed"]:
+            status = "[green]installed[/green]"
+        else:
+            status = "[dim]available[/dim]"
+        table.add_row(name, desc, status)
+    # Show user skills too
+    for name, kind in result["installed"].items():
+        if kind == "user":
+            table.add_row(name, "(user-created)", "[cyan]custom[/cyan]")
+    console.print(table)
+    if not result["agent"]:
+        console.print("\n[yellow]⚠[/yellow] No agent detected. Run 'loony init' first.")
+@skills_app.command("add")
+def skills_add(
+    name: str = typer.Argument(..., help="Skill name to add"),
+    agent: Optional[str] = typer.Option(None, "--agent", "-a", help="Agent type: claude, cursor, codex"),
+):
+    """Add a bundled skill to the project."""
+    from pathlib import Path
+    try:
+        result = skills_mod.add_skill(name, agent=agent, project_dir=Path.cwd())
+        console.print(f"[green]✓[/green] {result['action'].title()} skill [bold]{result['name']}[/bold]")
+        console.print(f"  {result['path']}")
+    except ValueError as e:
+        console.print(f"[red]✗[/red] {e}")
+        raise typer.Exit(1)
+@skills_app.command("remove")
+def skills_remove(
+    name: str = typer.Argument(..., help="Skill name to remove"),
+):
+    """Remove a skill from the project."""
+    from pathlib import Path
+    try:
+        result = skills_mod.remove_skill(name, project_dir=Path.cwd())
+        console.print(f"[green]✓[/green] Removed skill [bold]{result['name']}[/bold]")
+    except ValueError as e:
+        console.print(f"[red]✗[/red] {e}")
+        raise typer.Exit(1)
+if __name__ == "__main__":
+    app()

loony-0.1.2/loony/config.py ADDED Viewed

@@ -0,0 +1,77 @@
+"""Manages ~/.loony/config.yaml — environments, credentials, current context."""
+import os
+from pathlib import Path
+import yaml
+CONFIG_DIR = Path.home() / ".loony"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+DEFAULTS = {
+    "staging": {
+        "endpoint": "https://control-plane-staging-f80a.up.railway.app",
+        "workos_client_id": "client_01KM7YSX929XY123SB97D5VP2T",
+    },
+    "production": {
+        "endpoint": "",
+        "workos_client_id": "",
+    },
+}
+def _ensure_dir():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+def load() -> dict:
+    if not CONFIG_FILE.exists():
+        return {"current": "staging", "environments": {}}
+    with open(CONFIG_FILE) as f:
+        return yaml.safe_load(f) or {"current": "staging", "environments": {}}
+def save(config: dict):
+    _ensure_dir()
+    with open(CONFIG_FILE, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+def get_current_env() -> str:
+    return os.environ.get("LOONY_ENV", load().get("current", "staging"))
+def get_env_config(env: str | None = None) -> dict:
+    env = env or get_current_env()
+    config = load()
+    env_config = config.get("environments", {}).get(env, {})
+    defaults = DEFAULTS.get(env, {})
+    return {**defaults, **env_config}
+def set_current_env(env: str):
+    config = load()
+    config["current"] = env
+    save(config)
+def save_credentials(env: str, credentials: dict):
+    config = load()
+    if "environments" not in config:
+        config["environments"] = {}
+    if env not in config["environments"]:
+        config["environments"][env] = {}
+    config["environments"][env].update(credentials)
+    config["current"] = env
+    save(config)
+def clear_credentials(env: str):
+    config = load()
+    envs = config.get("environments", {})
+    if env in envs:
+        envs[env].pop("access_token", None)
+        envs[env].pop("refresh_token", None)
+        envs[env].pop("user_id", None)
+        envs[env].pop("email", None)
+    save(config)