Blame for app.py

#!/usr/bin/env python3
"""
AgentCTL Gradio UI (Frontend)
Communicates with FastAPI backend instead of Kubernetes directly
"""

import os
import time
import requests
import gradio as gr

# -------------------------------------------------------------------
# Backend URL (FastAPI)
# -------------------------------------------------------------------
BACKEND_URL = os.getenv(
    "AGENTCTL_BACKEND_URL",
    "http://127.0.0.1:9000"  # default for local development
)

print(f"AgentCTL Backend URL: {BACKEND_URL}")

# Helper to join backend URL
def api(path: str) -> str:
    return f"{BACKEND_URL}{path}"


# -------------------------------------------------------------------
# API Client Helpers
# -------------------------------------------------------------------

def generate_yaml(prompt: str, namespace: str, kind: str) -> str:
    """Call FastAPI: POST /api/generate-yaml"""
    try:
        payload = {
            "prompt": prompt,
            "namespace": namespace,
            "kind": kind
        }
        r = requests.post(api("/api/generate-yaml"), json=payload)
        r.raise_for_status()
        return r.json().get("yaml", "# No YAML returned")
    except Exception as e:
        return f"# ERROR: {e}"


def apply_yaml(yaml_text: str) -> tuple[str, str]:
    """Call FastAPI: POST /api/apply"""
    try:
        r = requests.post(api("/api/apply"), json={"yaml": yaml_text})
        r.raise_for_status()
        data = r.json()
        # Backend sends message + raw
        message = data.get("message", "")
        raw = data.get("raw", "")
        return message, raw
    except Exception as e:
        return f"ERROR: {e}", ""

def run_agent(instruction: str, namespace: str, kind: str):
    """Call FastAPI: POST /api/agent"""
    try:
        payload = {
            "instruction": instruction,
            "namespace": namespace,
            "kind": kind
        }
        r = requests.post(api("/api/agent"), json=payload)
        r.raise_for_status()

        data = r.json()

        yaml_text = data.get("yaml", "# No YAML")
        result = data.get("result", {})
        mode = data.get("mode", "unknown")
        model = data.get("model", "none")

        info = f"Mode: {mode}\nModel: {model}"

        return yaml_text, result, info

    except Exception as e:
        return f"# ERROR: {e}", {}, "ERROR"

def format_snapshot(data):
    lines = []

    lines.append(f"Namespace: {data.get('namespace','default')}\n")
    lines.append("==== JOBS ====\n")

    for job in data.get("jobs", []):
        if job["succeeded"] > 0:
            status = "Completed"
        elif job["failed"] > 0:
            status = "Failed"
        elif job["active"] > 0:
            status = "Active"
        else:
            status = "Pending"

        lines.append(
            f"{job['name']}: {status} | Active={job['active']} | Success={job['succeeded']} | Failed={job['failed']}"
        )

    lines.append("\n==== PODS ====\n")

    for pod in data.get("pods", []):
        phase = pod["phase"]
        lines.append(f"{pod['name']}: {phase}")

    lines.append("\n==== CRONJOBS ====\n")

    for cj in data.get("cronjobs", []):
        lines.append(
            f"{cj['name']}: Active={cj['active']} | LastSchedule={cj['last_schedule']}"
        )

    return "\n".join(lines)


def get_logs_once(pod_name: str, tail: int) -> str:
    """Call FastAPI: GET /api/logs"""
    try:
        params = {"pod_name": pod_name, "tail": tail}
        r = requests.get(api("/api/logs"), params=params)
        r.raise_for_status()
        return r.json().get("logs", "No logs received")
    except Exception as e:
        return f"ERROR: {e}"


def follow_logs(pod_name: str, tail: int):
    """Streaming logs (auto-refresh every 2s)"""
    while True:
        html = get_logs_once(pod_name, tail)
        yield html
        time.sleep(2)


# -------------------------------------------------------------------
# Gradio UI
# -------------------------------------------------------------------

def build_ui():
    with gr.Blocks(title="AgentCTL Frontend (FastAPI Backend)") as ui:

        gr.Markdown(f"""
# AgentCTL (Frontend)

Backend URL in use:
**{BACKEND_URL}**

Set `AGENTCTL_BACKEND_URL` to override.
---
""")

        # ----------------------------------------------------------
        # TAB 1 — Create Resource
        # ----------------------------------------------------------
        with gr.Tab("Create Resource"):
            with gr.Row():
                prompt = gr.Textbox(
                    label="Describe your resource",
                    lines=5,
                    placeholder=(
                        "Examples:\n"
                        "- run a python job to preprocess data\n"
                        "- create an nginx deployment with 3 replicas\n"
                        "- schedule a cleanup script every 5 minutes\n"
                    )
                )
                with gr.Column():
                    namespace = gr.Textbox(label="Namespace", value="default")
                    kind = gr.Dropdown(
                        label="Kind",
                        choices=["Auto", "Job", "Deployment", "CronJob"],
                        value="Auto"
                    )

            generate_btn = gr.Button("Generate YAML")
            yaml_box = gr.Code(label="Generated YAML", language="yaml")

            apply_btn = gr.Button("Apply YAML to Cluster")
            apply_status = gr.Textbox(label="Status")
            apply_raw = gr.Textbox(label="Raw API Response")

            generate_btn.click(
                fn=generate_yaml,
                inputs=[prompt, namespace, kind],
                outputs=yaml_box
            )
            apply_btn.click(
                fn=apply_yaml,
                inputs=[yaml_box],
                outputs=[apply_status, apply_raw]
            )

        # ----------------------------------------------------------
        # TAB 2 — Cluster Dashboard
        # ----------------------------------------------------------
        with gr.Tab("Cluster Dashboard"):
            refresh_button = gr.Button("Refresh Snapshot")
            snapshot_box = gr.Textbox(label="Cluster Snapshot", lines=25)

            def get_formatted_snapshot():
                try:
                    r = requests.get(api("/api/snapshot"))
                    r.raise_for_status()
                    data = r.json()
                    return format_snapshot(data)
                except Exception as e:
                    return f"ERROR fetching snapshot: {e}"

            refresh_button.click(
                fn=get_formatted_snapshot,
                outputs=snapshot_box
            )

        # ----------------------------------------------------------
        # TAB 3 — Pod Logs
        # ----------------------------------------------------------
        with gr.Tab("Pod Logs"):
            pod_name = gr.Textbox(label="Pod Name")
            tail_lines = gr.Slider(
                label="Tail Lines", minimum=10, maximum=500, value=100
            )

            get_logs_btn = gr.Button("Get Logs")
            follow_logs_btn = gr.Button("Follow Logs (Live)")
            logs_html = gr.HTML(label="Logs Terminal")

            get_logs_btn.click(
                fn=get_logs_once,
                inputs=[pod_name, tail_lines],
                outputs=logs_html
            )

            follow_logs_btn.click(
                fn=follow_logs,
                inputs=[pod_name, tail_lines],
                outputs=logs_html
            )

        # ----------------------------------------------------------
        # TAB 4 — Agent Mode (LLM → YAML → Apply)
        # ----------------------------------------------------------
        with gr.Tab("Agent Mode"):
            gr.Markdown("""
                ## Agentic LLM Mode
                Enter natural language instructions and let the backend agent:
                1. Plan the Kubernetes operation  
                2. Generate YAML (LLM → fallback → validated)
                3. Apply it to the cluster  
                """)

            instruction = gr.Textbox(
                label="Instruction",
                lines=4,
                placeholder="e.g. deploy a pytorch training job with 1 GPU"
            )

            namespace2 = gr.Textbox(
                label="Namespace",
                value="default"
            )

            kind2 = gr.Dropdown(
                label="Kind Override (optional)",
                choices=["Auto", "Job", "Deployment", "CronJob"],
                value="Auto"
            )

            run_btn = gr.Button("Run Agent")

            agent_yaml = gr.Code(label="Generated YAML", language="yaml")
            agent_result = gr.JSON(label="Apply Result")
            agent_info = gr.Textbox(label="Agent Info (LLM / Fallback)")


            run_btn.click(
                fn=run_agent,
                inputs=[instruction, namespace2, kind2],
                outputs=[agent_yaml, agent_result, agent_info]
            )



    return ui


# Build UI
app = build_ui()

if __name__ == "__main__":
    app.launch(server_name="0.0.0.0", server_port=7860)