kalibr 1.0.28__py3-none-any.whl → 1.1.0__py3-none-any.whl

kalibr/cli/deploy_cmd.py

@@ -0,0 +1,114 @@
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console()
+app = typer.Typer(no_args_is_help=True)
+
+
+# ────────────────────────────────────────────────────────────────────────────────
+# Utility: Ensure Flyctl CLI exists
+# ────────────────────────────────────────────────────────────────────────────────
+def _ensure_flyctl():
+    """Check that Flyctl CLI is installed and in PATH."""
+    os.environ["PATH"] += os.pathsep + os.path.expanduser("~/.fly/bin")
+    fly_path = shutil.which("flyctl") or shutil.which("fly")
+    if not fly_path:
+        console.print(
+            "❌ [red]Flyctl CLI not found. Install it from https://fly.io/docs/hands-on/install-flyctl/[/red]"
+        )
+        raise typer.Exit(code=1)
+    return fly_path
+
+
+# ────────────────────────────────────────────────────────────────────────────────
+# Main deploy command
+# ────────────────────────────────────────────────────────────────────────────────
+@app.command()
+def deploy(
+    file_path: str = typer.Argument(..., help="Path to your Python app file."),
+    runtime: str = typer.Option("fly", "--runtime", help="Runtime target (fly, render, or local)."),
+    app_name: str = typer.Option("kalibr-app", "--app-name", help="Name of the Fly.io app."),
+):
+    """
+    Deploy a Kalibr app to Fly.io or local runtime.
+    """
+    console.print(
+        f"[bold cyan]─────────────────────────── Deploying {file_path} ───────────────────────────[/bold cyan]"
+    )
+
+    # Verify file exists
+    app_path = Path(file_path).resolve()
+    if not app_path.exists():
+        console.print(f"❌ [red]File not found: {app_path}[/red]")
+        raise typer.Exit(code=1)
+
+    # ── Dockerfile ──────────────────────────────────────────────────────────────
+    dockerfile_path = app_path.parent / "Dockerfile"
+    if not dockerfile_path.exists():
+        console.print("🧱 Generating Dockerfile ...")
+        dockerfile_path.write_text(
+            f"""FROM python:3.11-slim
+WORKDIR /app
+COPY . .
+RUN pip install kalibr fastapi uvicorn
+CMD ["kalibr", "serve", "{app_path.name}"]
+"""
+        )
+        console.print(f"✅ Created [green]{dockerfile_path}[/green]")
+
+    # ── fly.toml ────────────────────────────────────────────────────────────────
+    fly_toml_path = app_path.parent / "fly.toml"
+    fly_toml_contents = f"""
+app = "{app_name}"
+primary_region = "iad"
+
+[build]
+  image = "python:3.11"
+
+[env]
+  PORT = "8000"
+
+[[services]]
+  internal_port = 8000
+  protocol = "tcp"
+
+  [[services.ports]]
+    port = 80
+    handlers = ["http"]
+
+  [[services.ports]]
+    port = 443
+    handlers = ["tls", "http"]
+""".strip()
+
+    fly_toml_path.write_text(fly_toml_contents)
+    console.print(
+        f"✅ Ensured [green]{fly_toml_path}[/green] includes app name: [bold]{app_name}[/bold]"
+    )
+
+    # ── Deploy ─────────────────────────────────────────────────────────────────
+    fly_path = _ensure_flyctl()
+    console.print(f"🚀 Deploying to Fly.io using [green]{fly_path}[/green]...")
+
+    try:
+        subprocess.run(["flyctl", "deploy", "--config", str(fly_toml_path)], check=True)
+        console.print(f"✅ [bold green]Deployment complete![/bold green]")
+        console.print(f"🌍 Visit your app at [underline]https://{app_name}.fly.dev[/underline]")
+    except subprocess.CalledProcessError:
+        console.print(f"❌ [red]Fly.io deployment failed[/red]")
+
+
+# ────────────────────────────────────────────────────────────────────────────────
+# Expose CLI entrypoint
+# ────────────────────────────────────────────────────────────────────────────────
+def get_app():
+    return app
+
+
+# Keep compatibility for `from kalibr.cli.deploy_cmd import deploy`
+deploy = deploy

kalibr/cli/main.py

@@ -0,0 +1,67 @@
+"""Main CLI entry point for Kalibr"""
+
+import typer
+from kalibr.cli.capsule_cmd import capsule
+from kalibr.cli.deploy_cmd import deploy
+from kalibr.cli.run import run
+
+# Import command functions
+from kalibr.cli.serve import serve
+from rich.console import Console
+
+app = typer.Typer(
+    name="kalibr",
+    help="Kalibr SDK - Multi-Model AI Integration Framework",
+    add_completion=False,
+)
+
+console = Console()
+
+# Register commands directly
+app.command(name="serve")(serve)
+app.command(name="deploy")(deploy)
+app.command(name="capsule")(capsule)
+app.command(name="run")(run)
+
+
+@app.command()
+def version():
+    """Show Kalibr SDK version"""
+    from kalibr import __version__
+
+    console.print(f"[bold]Kalibr SDK version:[/bold] {__version__}")
+    console.print("Enhanced multi-model AI integration framework")
+    console.print("Supports: GPT Actions, Claude MCP, Gemini Extensions, Copilot Plugins")
+    console.print("GitHub: https://github.com/devonakelley/kalibr-sdk")
+
+
+@app.command()
+def package():
+    """Create a deployable MCP bundle (code + schemas + metadata)."""
+    console.print("[yellow]📦 Package feature coming soon[/yellow]")
+    console.print("This will create a deployment bundle with all schemas.")
+
+
+@app.command()
+def validate():
+    """Validate MCP manifest against minimal JSON schema & version hint."""
+    console.print("[yellow]✓ Validation feature coming soon[/yellow]")
+
+
+@app.command()
+def update_schemas():
+    """Stub: instruct users to upgrade SDK and regenerate manifests."""
+    console.print("[cyan]ℹ️  To update schemas:[/cyan]")
+    console.print("1. pip install --upgrade kalibr")
+    console.print("2. Restart your kalibr serve command")
+    console.print("3. Schemas will be auto-regenerated")
+
+
+@app.command()
+def status():
+    """Check status of a deployed Kalibr app."""
+    console.print("[yellow]📊 Status checking coming soon[/yellow]")
+
+
+if __name__ == "__main__":
+    app()

kalibr/cli/run.py

@@ -0,0 +1,200 @@
+"""
+kalibr run - Managed runtime lifecycle for MCP servers
+Phase 3E - CLI Command
+"""
+
+import atexit
+import os
+import signal
+import subprocess
+import sys
+import time
+import uuid
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import typer
+from rich.console import Console
+
+console = Console()
+
+
+def run(
+    file_path: str = typer.Argument(..., help="Path to your Python agent file"),
+    runtime: str = typer.Option(
+        "local", "--runtime", "-r", help="Runtime provider (local, fly.io)"
+    ),
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind to (local only)"),
+    port: int = typer.Option(8000, "--port", "-p", help="Port to bind to (local only)"),
+    backend_url: Optional[str] = typer.Option(None, "--backend-url", help="Kalibr backend URL"),
+):
+    """
+    Run a Kalibr agent with managed runtime lifecycle.
+
+    Automatically:
+    - Registers runtime in backend
+    - Injects tracing middleware
+    - Emits capsules on completion
+    - Updates runtime status
+
+    Examples:
+
+        # Run locally
+        kalibr run weather.py
+
+        # Run on Fly.io
+        kalibr run weather.py --runtime fly.io
+
+        # Custom backend
+        kalibr run weather.py --backend-url https://api.kalibr.io
+    """
+    # Validate file exists
+    agent_path = Path(file_path).resolve()
+    if not agent_path.exists():
+        console.print(f"[red]❌ Error: File '{file_path}' not found[/red]")
+        raise typer.Exit(1)
+
+    # Configure backend
+    backend = backend_url or os.getenv("KALIBR_BACKEND_URL", "http://localhost:8001")
+    api_key = os.getenv("KALIBR_API_KEY", "test_key_12345")
+
+    # Generate runtime metadata
+    runtime_id = str(uuid.uuid4())
+    context_token = str(uuid.uuid4())
+    agent_name = agent_path.stem
+
+    console.print(f"[bold cyan]🚀 Starting Kalibr Runtime[/bold cyan]")
+    console.print(f"[dim]Agent:[/dim] {agent_name}")
+    console.print(f"[dim]Runtime ID:[/dim] {runtime_id}")
+    console.print(f"[dim]Context Token:[/dim] {context_token}")
+    console.print(f"[dim]Provider:[/dim] {runtime}")
+
+    # Register runtime
+    try:
+        with httpx.Client(timeout=10.0) as client:
+            response = client.post(
+                f"{backend}/api/runtimes/register",
+                json={
+                    "runtime_id": runtime_id,
+                    "agent_name": agent_name,
+                    "runtime_provider": runtime,
+                    "context_token": context_token,
+                },
+            )
+            response.raise_for_status()
+            console.print(f"[green]✓[/green] Runtime registered")
+    except Exception as e:
+        console.print(f"[yellow]⚠️ Failed to register runtime: {e}[/yellow]")
+        console.print("[yellow]Continuing without backend registration...[/yellow]")
+
+    # Setup environment variables
+    env = os.environ.copy()
+    env.update(
+        {
+            "KALIBR_RUNTIME_ID": runtime_id,
+            "KALIBR_CONTEXT_TOKEN": context_token,
+            "KALIBR_TRACE_ENABLED": "true",
+            "KALIBR_COLLECTOR_URL": f"{backend}/api/ingest",
+            "KALIBR_API_KEY": api_key,
+            "KALIBR_BACKEND_URL": backend,
+        }
+    )
+
+    # Store runtime metadata for cleanup
+    runtime_metadata = {
+        "runtime_id": runtime_id,
+        "backend": backend,
+        "api_key": api_key,
+        "start_time": time.time(),
+        "trace_count": 0,
+    }
+
+    # Register cleanup handler
+    def cleanup_runtime():
+        """Stop runtime and update backend"""
+        try:
+            duration = time.time() - runtime_metadata["start_time"]
+
+            with httpx.Client(timeout=10.0) as client:
+                client.patch(
+                    f"{backend}/api/runtimes/{runtime_id}/stop",
+                    json={
+                        "total_traces": runtime_metadata.get("trace_count", 0),
+                        "total_cost_usd": 0.0,  # Will be updated by capsule emission
+                        "total_latency_ms": int(duration * 1000),
+                    },
+                    headers={"X-API-Key": api_key},
+                )
+            console.print(f"[green]✓[/green] Runtime stopped")
+        except Exception as e:
+            console.print(f"[yellow]⚠️ Failed to stop runtime: {e}[/yellow]")
+
+    atexit.register(cleanup_runtime)
+
+    # Launch based on runtime provider
+    if runtime == "local":
+        # Local subprocess execution
+        console.print(f"\n[bold]Starting agent on {host}:{port}[/bold]")
+
+        try:
+            # Use kalibr serve to run the agent
+            cmd = [
+                sys.executable,
+                "-m",
+                "kalibr.cli.main",
+                "serve",
+                str(agent_path),
+                "--host",
+                host,
+                "--port",
+                str(port),
+            ]
+
+            process = subprocess.Popen(
+                cmd,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+            )
+
+            # Stream output
+            console.print("[dim]─" * 80 + "[/dim]")
+            for line in process.stdout:
+                print(line, end="")
+
+            process.wait()
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]⚠️ Received interrupt, stopping runtime...[/yellow]")
+            process.terminate()
+            process.wait(timeout=5)
+        except Exception as e:
+            console.print(f"[red]❌ Runtime error: {e}[/red]")
+            raise typer.Exit(1)
+
+    elif runtime == "fly.io":
+        # Fly.io deployment
+        console.print(f"\n[bold]Deploying to Fly.io[/bold]")
+
+        # Use existing deploy command
+        from kalibr.cli.deploy_cmd import deploy
+
+        deploy(
+            file_path=str(agent_path),
+            runtime="fly",
+            app_name=f"kalibr-{agent_name}",
+        )
+
+        console.print(f"[green]✓[/green] Deployed to Fly.io")
+
+    else:
+        console.print(f"[red]❌ Unsupported runtime: {runtime}[/red]")
+        console.print("[yellow]Supported runtimes: local, fly.io[/yellow]")
+        raise typer.Exit(1)
+
+    # Cleanup
+    cleanup_runtime()
+    console.print("\n[bold green]✓ Runtime completed[/bold green]")

kalibr/cli/serve.py

@@ -0,0 +1,59 @@
+"""Serve command for local development"""
+
+import importlib.util
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+
+def serve(
+    file_path: str = typer.Argument(..., help="Path to your Kalibr app (e.g. app.py)"),
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind to"),
+    port: int = typer.Option(8000, "--port", "-p", help="Port to bind to"),
+):
+    """Serve a Kalibr-powered API locally."""
+    path = Path(file_path)
+
+    if not path.exists():
+        console.print(f"[red]❌ Error: File '{file_path}' not found[/red]")
+        raise typer.Exit(1)
+
+    try:
+        # Load the module
+        spec = importlib.util.spec_from_file_location("user_app", path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        # Find Kalibr app instance
+        app_instance = None
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if hasattr(attr, "app") and hasattr(attr.app, "openapi"):
+                app_instance = attr
+                break
+
+        if not app_instance:
+            console.print(f"[red]❌ Error loading {file_path}: No Kalibr app found[/red]")
+            raise typer.Exit(1)
+
+        # Display startup info
+        console.print(f"[bold green]🚀 Starting Kalibr server from {path.name}[/bold green]")
+        display_host = "localhost" if host == "0.0.0.0" else host
+        console.print(f"📍 GPT (OpenAPI):     http://{display_host}:{port}/openapi.json")
+        console.print(f"📍 Claude (MCP):      http://{display_host}:{port}/mcp.json")
+        console.print(f"📍 Swagger UI:        http://{display_host}:{port}/docs")
+        console.print(
+            f"🔌 Actions registered: {[action['name'] for action in app_instance.actions]}"
+        )
+
+        # Run the server
+        import uvicorn
+
+        uvicorn.run(app_instance.app, host=host, port=port)
+
+    except Exception as e:
+        console.print(f"[red]❌ Error loading {file_path}: {str(e)}[/red]")
+        raise typer.Exit(1)