Sync from GitHub on master (Thu Nov 20 11:13:32 UTC 2025)

app.py

@@ -81,11 +81,6 @@ def run_agent(instruction: str, namespace: str, kind: str):
     except Exception as e:
         return f"# ERROR: {e}", {}, "ERROR"
 
-
-# -------------------------------------------------------------------
-# Snapshot Formatter (Emoji-Free)
-# -------------------------------------------------------------------
-
 def format_snapshot(data):
     lines = []
 

hf-space/agentctl/llm.py

@@ -5,48 +5,69 @@ from huggingface_hub import InferenceClient
 HF_TOKEN = os.getenv("HF_TOKEN")
 HF_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
 
-client = InferenceClient(token=HF_TOKEN, timeout=120)
+client = InferenceClient(
+    token=HF_TOKEN,
+    timeout=120
+)
 
 def _hf_call(prompt: str) -> str:
+    """
+    Safe HF call:
+      - Uses chat_completion
+      - Cleans code fencing
+      - Hard-fails quietly so AgentService can fallback
+    """
     try:
-        messages = [
-            {"role": "user", "content": prompt}
-        ]
-
         response = client.chat_completion(
-            messages,
-            model=HF_MODEL, 
-            max_tokens=500,
-            temperature=0.2, 
+            model=HF_MODEL,
+            messages=[
+                {
+                    "role": "system",
+                    "content": (
+                        "You are a STRICT Kubernetes generator. "
+                        "You MUST always generate minimal, safe YAML.\n"
+                        "YOU MUST OBEY:\n"
+                        "- Create ONLY simple CPU-only Jobs.\n"
+                        "- NEVER use GPU.\n"
+                        "- NEVER use PyTorch, TensorFlow, ML training, train.py.\n"
+                        "- Allowed images ONLY: busybox OR python:3.10-slim.\n"
+                        "- Commands must be simple: echo, sleep, ls.\n"
+                        "- Memory <= 256Mi, CPU <= 250m.\n"
+                        "- No external registries.\n"
+                        "- Must fit in Minikube.\n"
+                        "- YAML must ALWAYS be short, valid, deterministic.\n"
+                    )
+                },
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=400,
+            temperature=0.2,
             top_p=0.9,
             stream=False
         )
-        
-        if response and response.choices:
-            content = response.choices[0].message.content
-            
-            # --- CLEANUP LOGIC START ---
-            # The model often wraps code in ```yaml ... ```. We must strip this.
-            lines = content.strip().splitlines()
-            
-            # Remove the top line if it starts with ``` (e.g., ```yaml)
-            if lines and lines[0].strip().startswith("```"):
-                lines = lines[1:]
-            
-            # Remove the bottom line if it is just ```
-            if lines and lines[-1].strip().startswith("```"):
-                lines = lines[:-1]
-            
-            return "\n".join(lines).strip()
-            # --- CLEANUP LOGIC END ---
-
-        print("[HF WARNING] Received empty response structure.")
-        return ""
+
+        if not response or not response.choices:
+            print("[HF WARNING] Empty response structure")
+            return ""
+
+        content = response.choices[0].message.content.strip()
+
+        # -------- Clean ```yaml fencing ----------
+        lines = content.splitlines()
+
+        if lines and lines[0].strip().startswith("```"):
+            lines = lines[1:]
+
+        if lines and lines[-1].strip().startswith("```"):
+            lines = lines[:-1]
+
+        return "\n".join(lines).strip()
 
     except Exception as e:
         print(f"[HF LLM ERROR] {e}")
         return ""
 
+
 async def ask_llm(prompt: str) -> str:
     loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, lambda: _hf_call(prompt))
+    return await loop.run_in_executor(None, lambda: _hf_call(prompt))

hf-space/backend/services/agent_service.py

@@ -42,10 +42,25 @@ class AgentService:
         # 1) LLM PLAN STEP
         # -------------------------------
         plan_prompt = f"""
-        You are an expert Kubernetes engineer.
-        Convert this natural-language instruction into a step-by-step plan.
-        Instruction: {prompt}
-        """
+            Convert this plan into valid Kubernetes YAML.
+            HARD RULES:
+            - kind: Job
+            - image: busybox or python:3.10-slim only
+            - restartPolicy: Never
+            - No GPUs, no ML, no training.
+            - Commands MUST be simple (echo/sleep/ls)
+            - No markdown
+            - No commentary
+
+            Plan:
+            {prompt}
+            Output:
+            - workload type
+            - image
+            - command
+            - args
+            """
+
 
         try:
             plan = await ask_llm(plan_prompt)

hf-space/hf-space/agentctl/llm.py

@@ -1,12 +1,52 @@
-# agentctl/llm.py
 import os
-from openai import OpenAI
+import asyncio
+from huggingface_hub import InferenceClient
 
-client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+HF_TOKEN = os.getenv("HF_TOKEN")
+HF_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
 
-async def ask_llm(prompt: str, model="gpt-4.1"):
-    res = client.chat.completions.create(
-        model=model,
-        messages=[{"role": "user", "content": prompt}]
-    )
-    return res.choices[0].message.content
+client = InferenceClient(token=HF_TOKEN, timeout=120)
+
+def _hf_call(prompt: str) -> str:
+    try:
+        messages = [
+            {"role": "user", "content": prompt}
+        ]
+
+        response = client.chat_completion(
+            messages,
+            model=HF_MODEL, 
+            max_tokens=500,
+            temperature=0.2, 
+            top_p=0.9,
+            stream=False
+        )
+        
+        if response and response.choices:
+            content = response.choices[0].message.content
+            
+            # --- CLEANUP LOGIC START ---
+            # The model often wraps code in ```yaml ... ```. We must strip this.
+            lines = content.strip().splitlines()
+            
+            # Remove the top line if it starts with ``` (e.g., ```yaml)
+            if lines and lines[0].strip().startswith("```"):
+                lines = lines[1:]
+            
+            # Remove the bottom line if it is just ```
+            if lines and lines[-1].strip().startswith("```"):
+                lines = lines[:-1]
+            
+            return "\n".join(lines).strip()
+            # --- CLEANUP LOGIC END ---
+
+        print("[HF WARNING] Received empty response structure.")
+        return ""
+
+    except Exception as e:
+        print(f"[HF LLM ERROR] {e}")
+        return ""
+
+async def ask_llm(prompt: str) -> str:
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, lambda: _hf_call(prompt))

hf-space/hf-space/app.py

@@ -68,12 +68,19 @@ def run_agent(instruction: str, namespace: str, kind: str):
         r.raise_for_status()
 
         data = r.json()
-        return (
-            data.get("yaml", "# No YAML"), 
-            data.get("result", {})
-        )
+
+        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}", {}
+        return f"# ERROR: {e}", {}, "ERROR"
+
 
 # -------------------------------------------------------------------
 # Snapshot Formatter (Emoji-Free)
@@ -270,14 +277,18 @@ Set `AGENTCTL_BACKEND_URL` to override.
             run_btn = gr.Button("Run Agent")
 
             agent_yaml = gr.Code(label="Generated YAML", language="yaml")
-            agent_result = gr.JSON(label="API Apply Result")
+            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]
+                outputs=[agent_yaml, agent_result, agent_info]
             )
 
+
+
     return ui
 
 

hf-space/hf-space/backend/routers/agent.py

@@ -13,7 +13,7 @@ async def run_agent(payload: dict):
     Agentic flow:
       1. LLM → Plan → YAML (fallback: K8sAgent)
       2. Apply YAML to Kubernetes
-      3. Return plan, yaml, result
+      3. Return yaml, mode, model, result
     """
 
     instruction = payload.get("instruction")
@@ -23,13 +23,17 @@ async def run_agent(payload: dict):
     if not instruction:
         raise HTTPException(status_code=400, detail="Missing instruction")
 
-    # 1. Generate YAML (LLM + fallback)
-    yaml_text = await agent_service.generate_yaml(
+    # 1. Generate YAML (LLM + fallback) → returns dict
+    agent_output = await agent_service.generate_yaml(
         instruction,
         namespace,
         kind
     )
 
+    yaml_text = agent_output["yaml"]
+    mode = agent_output["mode"]
+    model = agent_output["model"]
+
     # 2. Apply YAML to K8s
     client = K8sClient()
     try:
@@ -37,8 +41,11 @@ async def run_agent(payload: dict):
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"K8s apply failed: {e}")
 
+    # 3. Return everything to UI
     return {
         "instruction": instruction,
         "yaml": yaml_text,
+        "mode": mode,
+        "model": model,
         "result": apply_result
     }

hf-space/hf-space/backend/services/agent_service.py

@@ -3,7 +3,7 @@ import yaml
 
 from agentctl.agent import K8sAgent
 from agentctl.config import settings
-from agentctl.llm import ask_llm
+from agentctl.llm import ask_llm, HF_MODEL  # <--- import model name
 
 
 def randomize_name(yaml_text: str) -> str:
@@ -28,88 +28,75 @@ def randomize_name(yaml_text: str) -> str:
 
     except Exception:
         return yaml_text
+    
 
 class AgentService:
-    """
-    Upgraded AgentService:
-    - Primary: LLM generates plan → YAML
-    - Fallback: Use existing K8sAgent.nl_to_resource_yaml
-    """
     def __init__(self):
-        # Your existing rule-based agent
         self.agent = K8sAgent()
 
     async def generate_yaml(self, prompt: str, namespace: str | None, kind: str | None):
-        # default namespace
         ns = namespace or settings.k8s_namespace
         kind_sel = None if (kind is None or kind == "Auto") else kind
 
         # -------------------------------
-        # 1) LLM Planning Step
+        # 1) LLM PLAN STEP
         # -------------------------------
         plan_prompt = f"""
         You are an expert Kubernetes engineer.
-
-        Convert this natural-language instruction into a detailed,
-        step-by-step Kubernetes workload plan (NO YAML yet).
-
-        Instruction:
-        {prompt}
-
-        Include:
-        - workload type (Job / Deployment / CronJob)
-        - container image
-        - commands/args
-        - resources
-        - environment variables
-        - namespace: {ns}
-        - override kind (if the user forced one): {kind_sel or "Auto"}
+        Convert this natural-language instruction into a step-by-step plan.
+        Instruction: {prompt}
         """
 
         try:
             plan = await ask_llm(plan_prompt)
+
         except Exception as e:
-            print(f"[LLM ERROR: plan] Falling back. Error: {e}")
-            # fallback immediately
+            print(f"[LLM ERROR: plan] Fallback. Error: {e}")
+
             _, yaml_text = self.agent.nl_to_resource_yaml(
-                prompt,
-                namespace=ns,
-                kind=kind_sel,
+                prompt, namespace=ns, kind=kind_sel
             )
-            return yaml_text
+
+            return {
+                "yaml": randomize_name(yaml_text),
+                "mode": "fallback",
+                "model": None
+            }
 
         # -------------------------------
-        # 2) LLM YAML Generation Step
+        # 2) LLM YAML STEP
         # -------------------------------
         yaml_prompt = f"""
-        Convert the following Kubernetes plan into VALID Kubernetes YAML.
-        Output only the YAML (no explanation, no markdown).
+        Convert this Kubernetes plan into valid Kubernetes YAML.
+        Output ONLY YAML:
 
-        Plan:
         {plan}
         """
 
         try:
             yaml_text = await ask_llm(yaml_prompt)
 
-            # sanity: avoid hallucinated empty responses
-            if not yaml_text or len(yaml_text.strip()) == 0:
+            if not yaml_text or yaml_text.strip() == "":
                 raise ValueError("Empty YAML from LLM")
 
-            return randomize_name(yaml_text)
+            return {
+                "yaml": randomize_name(yaml_text),
+                "mode": "llm",
+                "model": HF_MODEL
+            }
 
         except Exception as e:
-            print(f"[LLM ERROR: yaml] Falling back. Error: {e}")
+            print(f"[LLM ERROR: yaml] Fallback. Error: {e}")
 
-            # -------------------------------
-            # 3) Fallback to your legacy NLP → YAML
-            # -------------------------------
             _, yaml_text = self.agent.nl_to_resource_yaml(
-                prompt,
-                namespace=ns,
-                kind=kind_sel,
+                prompt, namespace=ns, kind=kind_sel
             )
-            return randomize_name(yaml_text)
 
-# Shared singleton
+            return {
+                "yaml": randomize_name(yaml_text),
+                "mode": "fallback",
+                "model": None
+            }
+
+
 agent_service = AgentService()

hf-space/hf-space/hf-space/agentctl/llm.py

@@ -0,0 +1,12 @@
+# agentctl/llm.py
+import os
+from openai import OpenAI
+
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+async def ask_llm(prompt: str, model="gpt-4.1"):
+    res = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return res.choices[0].message.content

hf-space/hf-space/hf-space/backend/main.py

@@ -1,7 +1,7 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from backend.routers import yaml_gen, apply, snapshot, logs
+from backend.routers import yaml_gen, apply, snapshot, logs, agent
 
 app = FastAPI(
     title="AgentCTL Backend API",
@@ -30,7 +30,7 @@ app.include_router(yaml_gen.router, prefix="/api")
 app.include_router(apply.router, prefix="/api")
 app.include_router(snapshot.router, prefix="/api")
 app.include_router(logs.router, prefix="/api")
-
+app.include_router(agent.router, prefix="/api") 
 
 @app.get("/debug-env")
 def debug_env():

hf-space/hf-space/hf-space/backend/routers/agent.py

@@ -0,0 +1,44 @@
+# routers/agent.py
+
+from fastapi import APIRouter, HTTPException
+from backend.services.agent_service import agent_service
+from agentctl.k8s_client import K8sClient
+
+router = APIRouter()
+
+
+@router.post("/agent")
+async def run_agent(payload: dict):
+    """
+    Agentic flow:
+      1. LLM → Plan → YAML (fallback: K8sAgent)
+      2. Apply YAML to Kubernetes
+      3. Return plan, yaml, result
+    """
+
+    instruction = payload.get("instruction")
+    namespace  = payload.get("namespace")
+    kind       = payload.get("kind")
+
+    if not instruction:
+        raise HTTPException(status_code=400, detail="Missing instruction")
+
+    # 1. Generate YAML (LLM + fallback)
+    yaml_text = await agent_service.generate_yaml(
+        instruction,
+        namespace,
+        kind
+    )
+
+    # 2. Apply YAML to K8s
+    client = K8sClient()
+    try:
+        apply_result = client.apply_manifest(yaml_text)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"K8s apply failed: {e}")
+
+    return {
+        "instruction": instruction,
+        "yaml": yaml_text,
+        "result": apply_result
+    }

hf-space/hf-space/hf-space/backend/services/agent_service.py

@@ -1,29 +1,115 @@
+import uuid
+import yaml
+
 from agentctl.agent import K8sAgent
 from agentctl.config import settings
+from agentctl.llm import ask_llm
+
+
+def randomize_name(yaml_text: str) -> str:
+    try:
+        obj = yaml.safe_load(yaml_text)
+        if not isinstance(obj, dict):
+            return yaml_text
+
+        kind = obj.get("kind")
+        if kind not in ("Job", "Deployment", "CronJob"):
+            return yaml_text
+
+        metadata = obj.setdefault("metadata", {})
+        name = metadata.get("name")
+        if not name:
+            return yaml_text
 
+        suffix = str(uuid.uuid4())[:5]
+        metadata["name"] = f"{name}-{suffix}"
+
+        return yaml.dump(obj, sort_keys=False)
+
+    except Exception:
+        return yaml_text
 
 class AgentService:
     """
-    Wrapper for the LLM → YAML agent.
+    Upgraded AgentService:
+    - Primary: LLM generates plan → YAML
+    - Fallback: Use existing K8sAgent.nl_to_resource_yaml
     """
-
     def __init__(self):
+        # Your existing rule-based agent
         self.agent = K8sAgent()
 
-    def generate_yaml(self, prompt: str, namespace: str | None, kind: str | None):
-        # fallback to default namespace from config
+    async def generate_yaml(self, prompt: str, namespace: str | None, kind: str | None):
+        # default namespace
         ns = namespace or settings.k8s_namespace
         kind_sel = None if (kind is None or kind == "Auto") else kind
 
-        # returns: (explanation, yaml_text)
-        _, yaml_text = self.agent.nl_to_resource_yaml(
-            prompt,
-            namespace=ns,
-            kind=kind_sel,
-        )
+        # -------------------------------
+        # 1) LLM Planning Step
+        # -------------------------------
+        plan_prompt = f"""
+        You are an expert Kubernetes engineer.
 
-        return yaml_text
+        Convert this natural-language instruction into a detailed,
+        step-by-step Kubernetes workload plan (NO YAML yet).
+
+        Instruction:
+        {prompt}
+
+        Include:
+        - workload type (Job / Deployment / CronJob)
+        - container image
+        - commands/args
+        - resources
+        - environment variables
+        - namespace: {ns}
+        - override kind (if the user forced one): {kind_sel or "Auto"}
+        """
+
+        try:
+            plan = await ask_llm(plan_prompt)
+        except Exception as e:
+            print(f"[LLM ERROR: plan] Falling back. Error: {e}")
+            # fallback immediately
+            _, yaml_text = self.agent.nl_to_resource_yaml(
+                prompt,
+                namespace=ns,
+                kind=kind_sel,
+            )
+            return yaml_text
+
+        # -------------------------------
+        # 2) LLM YAML Generation Step
+        # -------------------------------
+        yaml_prompt = f"""
+        Convert the following Kubernetes plan into VALID Kubernetes YAML.
+        Output only the YAML (no explanation, no markdown).
+
+        Plan:
+        {plan}
+        """
+
+        try:
+            yaml_text = await ask_llm(yaml_prompt)
+
+            # sanity: avoid hallucinated empty responses
+            if not yaml_text or len(yaml_text.strip()) == 0:
+                raise ValueError("Empty YAML from LLM")
+
+            return randomize_name(yaml_text)
+
+        except Exception as e:
+            print(f"[LLM ERROR: yaml] Falling back. Error: {e}")
 
+            # -------------------------------
+            # 3) Fallback to your legacy NLP → YAML
+            # -------------------------------
+            _, yaml_text = self.agent.nl_to_resource_yaml(
+                prompt,
+                namespace=ns,
+                kind=kind_sel,
+            )
+            return randomize_name(yaml_text)
 
 # Shared singleton
 agent_service = AgentService()

hf-space/hf-space/hf-space/hf-space/app.py

@@ -17,7 +17,7 @@ BACKEND_URL = os.getenv(
     "http://127.0.0.1:9000"  # default for local development
 )
 
-print(f"🔗 AgentCTL Backend URL: {BACKEND_URL}")
+print(f"AgentCTL Backend URL: {BACKEND_URL}")
 
 # Helper to join backend URL
 def api(path: str) -> str:
@@ -44,41 +44,75 @@ def generate_yaml(prompt: str, namespace: str, kind: str) -> str:
 
 
 def apply_yaml(yaml_text: str) -> tuple[str, str]:
-    """
-    Call FastAPI: POST /api/apply
-    Backend returns:
-        { "success": bool, "message": str, "raw": str }
-    """
+    """Call FastAPI: POST /api/apply"""
     try:
         r = requests.post(api("/api/apply"), json={"yaml": yaml_text})
         r.raise_for_status()
         data = r.json()
-
-        # CORRECT FIX: backend sends "message" not "status"
+        # Backend sends message + raw
         message = data.get("message", "")
         raw = data.get("raw", "")
-
         return message, raw
-
     except Exception as e:
-        return f"❌ ERROR: {e}", ""
+        return f"ERROR: {e}", ""
 
-
-def get_snapshot() -> str:
-    """
-    Call FastAPI: GET /api/snapshot
-    Backend returns JSON (not 'snapshot' field)
-    We must pretty-format the JSON output.
-    """
+def run_agent(instruction: str, namespace: str, kind: str):
+    """Call FastAPI: POST /api/agent"""
     try:
-        r = requests.get(api("/api/snapshot"))
+        payload = {
+            "instruction": instruction,
+            "namespace": namespace,
+            "kind": kind
+        }
+        r = requests.post(api("/api/agent"), json=payload)
         r.raise_for_status()
-        data = r.json()
-        import json
-        return json.dumps(data, indent=2)
 
+        data = r.json()
+        return (
+            data.get("yaml", "# No YAML"), 
+            data.get("result", {})
+        )
     except Exception as e:
-        return f"ERROR fetching snapshot: {e}"
+        return f"# ERROR: {e}", {}
+
+# -------------------------------------------------------------------
+# Snapshot Formatter (Emoji-Free)
+# -------------------------------------------------------------------
+
+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:
@@ -89,7 +123,7 @@ def get_logs_once(pod_name: str, tail: int) -> str:
         r.raise_for_status()
         return r.json().get("logs", "No logs received")
     except Exception as e:
-        return f"<span style='color:red;'>ERROR: {e}</span>"
+        return f"ERROR: {e}"
 
 
 def follow_logs(pod_name: str, tail: int):
@@ -108,13 +142,12 @@ def build_ui():
     with gr.Blocks(title="AgentCTL Frontend (FastAPI Backend)") as ui:
 
         gr.Markdown(f"""
-# 🚀 AgentCTL (Frontend)
-FastAPI Backend URL in use:
+# AgentCTL (Frontend)
 
-### **🔗 {BACKEND_URL}**
+Backend URL in use:
+**{BACKEND_URL}**
 
 Set `AGENTCTL_BACKEND_URL` to override.
-
 ---
 """)
 
@@ -133,22 +166,18 @@ Set `AGENTCTL_BACKEND_URL` to override.
                         "- schedule a cleanup script every 5 minutes\n"
                     )
                 )
-
                 with gr.Column():
-                    namespace = gr.Textbox(
-                        label="Namespace",
-                        value="default"
-                    )
+                    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", variant="primary")
+            generate_btn = gr.Button("Generate YAML")
             yaml_box = gr.Code(label="Generated YAML", language="yaml")
 
-            apply_btn = gr.Button("Apply YAML to Cluster", variant="primary")
+            apply_btn = gr.Button("Apply YAML to Cluster")
             apply_status = gr.Textbox(label="Status")
             apply_raw = gr.Textbox(label="Raw API Response")
 
@@ -157,7 +186,6 @@ Set `AGENTCTL_BACKEND_URL` to override.
                 inputs=[prompt, namespace, kind],
                 outputs=yaml_box
             )
-
             apply_btn.click(
                 fn=apply_yaml,
                 inputs=[yaml_box],
@@ -168,10 +196,22 @@ Set `AGENTCTL_BACKEND_URL` to override.
         # TAB 2 — Cluster Dashboard
         # ----------------------------------------------------------
         with gr.Tab("Cluster Dashboard"):
-            refresh_button = gr.Button("Refresh Snapshot", variant="primary")
+            refresh_button = gr.Button("Refresh Snapshot")
             snapshot_box = gr.Textbox(label="Cluster Snapshot", lines=25)
 
-            refresh_button.click(fn=get_snapshot, outputs=snapshot_box)
+            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
@@ -179,14 +219,11 @@ Set `AGENTCTL_BACKEND_URL` to override.
         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
+                label="Tail Lines", minimum=10, maximum=500, value=100
             )
 
             get_logs_btn = gr.Button("Get Logs")
-            follow_logs_btn = gr.Button("Follow Logs (Live)", variant="primary")
+            follow_logs_btn = gr.Button("Follow Logs (Live)")
             logs_html = gr.HTML(label="Logs Terminal")
 
             get_logs_btn.click(
@@ -201,6 +238,46 @@ Set `AGENTCTL_BACKEND_URL` to override.
                 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="API Apply Result")
+
+            run_btn.click(
+                fn=run_agent,
+                inputs=[instruction, namespace2, kind2],
+                outputs=[agent_yaml, agent_result]
+            )
+
     return ui
 
 

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -17,6 +17,8 @@ BACKEND_URL = os.getenv(
     "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}"
@@ -42,22 +44,39 @@ def generate_yaml(prompt: str, namespace: str, kind: str) -> str:
 
 
 def apply_yaml(yaml_text: str) -> tuple[str, str]:
-    """Call FastAPI: POST /api/apply"""
+    """
+    Call FastAPI: POST /api/apply
+    Backend returns:
+        { "success": bool, "message": str, "raw": str }
+    """
     try:
         r = requests.post(api("/api/apply"), json={"yaml": yaml_text})
         r.raise_for_status()
         data = r.json()
-        return data.get("status", ""), data.get("raw", "")
+
+        # CORRECT FIX: backend sends "message" not "status"
+        message = data.get("message", "")
+        raw = data.get("raw", "")
+
+        return message, raw
+
     except Exception as e:
         return f"❌ ERROR: {e}", ""
 
 
 def get_snapshot() -> str:
-    """Call FastAPI: GET /api/snapshot"""
+    """
+    Call FastAPI: GET /api/snapshot
+    Backend returns JSON (not 'snapshot' field)
+    We must pretty-format the JSON output.
+    """
     try:
         r = requests.get(api("/api/snapshot"))
         r.raise_for_status()
-        return r.json().get("snapshot", "No snapshot available")
+        data = r.json()
+        import json
+        return json.dumps(data, indent=2)
+
     except Exception as e:
         return f"ERROR fetching snapshot: {e}"
 
@@ -74,7 +93,7 @@ def get_logs_once(pod_name: str, tail: int) -> str:
 
 
 def follow_logs(pod_name: str, tail: int):
-    """Streaming generator for follow logs."""
+    """Streaming logs (auto-refresh every 2s)"""
     while True:
         html = get_logs_once(pod_name, tail)
         yield html
@@ -94,7 +113,7 @@ FastAPI Backend URL in use:
 
 ### **🔗 {BACKEND_URL}**
 
-_(Set AGENTCTL_BACKEND_URL environment variable to override)_
+Set `AGENTCTL_BACKEND_URL` to override.
 
 ---
 """)
@@ -146,7 +165,7 @@ _(Set AGENTCTL_BACKEND_URL environment variable to override)_
             )
 
         # ----------------------------------------------------------
-        # TAB 2 — Dashboard
+        # TAB 2 — Cluster Dashboard
         # ----------------------------------------------------------
         with gr.Tab("Cluster Dashboard"):
             refresh_button = gr.Button("Refresh Snapshot", variant="primary")
@@ -155,7 +174,7 @@ _(Set AGENTCTL_BACKEND_URL environment variable to override)_
             refresh_button.click(fn=get_snapshot, outputs=snapshot_box)
 
         # ----------------------------------------------------------
-        # TAB 3 — Pods Logs
+        # TAB 3 — Pod Logs
         # ----------------------------------------------------------
         with gr.Tab("Pod Logs"):
             pod_name = gr.Textbox(label="Pod Name")

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/k8s_client.py

@@ -18,6 +18,8 @@ from .schemas import (
     CronJobStatus,
 )
 
+from dotenv import load_dotenv
+load_dotenv()
 
 class K8sClient:
     def __init__(self, base_url: str | None = None, namespace: str | None = None):

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/main.py

@@ -30,3 +30,13 @@ app.include_router(yaml_gen.router, prefix="/api")
 app.include_router(apply.router, prefix="/api")
 app.include_router(snapshot.router, prefix="/api")
 app.include_router(logs.router, prefix="/api")
+
+
+@app.get("/debug-env")
+def debug_env():
+    import os
+    return {
+        "K8S_API_BASE_URL": os.getenv("K8S_API_BASE_URL"),
+        "K8S_NAMESPACE": os.getenv("K8S_NAMESPACE"),
+        "K8S_VERIFY_SSL": os.getenv("K8S_VERIFY_SSL")
+    }

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -1,314 +1,192 @@
 #!/usr/bin/env python3
+"""
+AgentCTL Gradio UI (Frontend)
+Communicates with FastAPI backend instead of Kubernetes directly
+"""
 
 import os
-import re
 import time
-import uuid
-import yaml
-from typing import Tuple
-
+import requests
 import gradio as gr
 
-from agentctl.config import settings
-from agentctl.k8s_client import K8sClient
-from agentctl.agent import K8sAgent
-
-
-# ---------------------------------------------------------------------
-# Core - Agent + Client
-# ---------------------------------------------------------------------
+# -------------------------------------------------------------------
+# Backend URL (FastAPI)
+# -------------------------------------------------------------------
+BACKEND_URL = os.getenv(
+    "AGENTCTL_BACKEND_URL",
+    "http://127.0.0.1:9000"  # default for local development
+)
 
-agent = K8sAgent()
+# Helper to join backend URL
+def api(path: str) -> str:
+    return f"{BACKEND_URL}{path}"
 
-def _get_client() -> K8sClient:
-    return K8sClient()
 
+# -------------------------------------------------------------------
+# API Client Helpers
+# -------------------------------------------------------------------
 
-# ---------------------------------------------------------------------
-# Unique Name Injection
-# ---------------------------------------------------------------------
-
-def _inject_unique_name(yaml_text: str) -> str:
-    """
-    Add unique suffix to metadata.name for Job, Deployment, CronJob.
-    Prevents 409 AlreadyExists errors.
-    """
+def generate_yaml(prompt: str, namespace: str, kind: str) -> str:
+    """Call FastAPI: POST /api/generate-yaml"""
     try:
-        data = yaml.safe_load(yaml_text)
-        if not isinstance(data, dict):
-            return yaml_text
-
-        kind = data.get("kind")
-        if kind not in {"Job", "CronJob", "Deployment"}:
-            return yaml_text
-
-        base = data["metadata"]["name"]
-        suffix = str(uuid.uuid4())[:5]
-        new_name = f"{base}-{suffix}"
-        data["metadata"]["name"] = new_name
-
-        # Patch CronJob template labels
-        if kind == "CronJob":
-            jt = data["spec"]["jobTemplate"]["spec"]["template"]
-            if "metadata" in jt:
-                if "labels" in jt["metadata"]:
-                    jt["metadata"]["labels"]["app"] = new_name
-                else:
-                    jt["metadata"]["labels"] = {"app": new_name}
-
-        return yaml.safe_dump(data)
-
-    except Exception:
-        return yaml_text
-
-
-# ---------------------------------------------------------------------
-# YAML Generation + Apply
-# ---------------------------------------------------------------------
-
-def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
-    if not prompt.strip():
-        return "# Enter a description, e.g. 'run a python preprocessing job'"
-
-    ns = namespace.strip() or settings.k8s_namespace
-    kind_sel = None if kind == "Auto" else kind
-
-    _, yaml_text = agent.nl_to_resource_yaml(prompt, namespace=ns, kind=kind_sel)
-    return yaml_text
-
-
-def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
-    if not yaml_text.strip():
-        return "No YAML to apply.", ""
-
-    yaml_text = _inject_unique_name(yaml_text)
-
-    client = _get_client()
-    result = client.apply_manifest(yaml_text)
-
+        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:
-        raw = str(result.raw_response)
-    except:
-        raw = "<unserialisable>"
-
-    prefix = "✅" if result.success else "❌"
-    return f"{prefix} {result.message}", raw
+        r = requests.post(api("/api/apply"), json={"yaml": yaml_text})
+        r.raise_for_status()
+        data = r.json()
+        return data.get("status", ""), data.get("raw", "")
+    except Exception as e:
+        return f"❌ ERROR: {e}", ""
 
 
-# ---------------------------------------------------------------------
-# Cluster Snapshot
-# ---------------------------------------------------------------------
+def get_snapshot() -> str:
+    """Call FastAPI: GET /api/snapshot"""
+    try:
+        r = requests.get(api("/api/snapshot"))
+        r.raise_for_status()
+        return r.json().get("snapshot", "No snapshot available")
+    except Exception as e:
+        return f"ERROR fetching snapshot: {e}"
 
-def get_cluster_snapshot() -> str:
-    client = _get_client()
-    snap = client.snapshot()
 
-    out = [f"Namespace: {snap.namespace}", ""]
+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"<span style='color:red;'>ERROR: {e}</span>"
 
-    out.append("Jobs:")
-    if not snap.jobs:
-        out.append("  (no jobs)")
-    else:
-        for j in snap.jobs:
-            out.append(
-                f"  - {j.name}: succeeded={j.succeeded}, failed={j.failed}, active={j.active}"
-            )
 
-    out.append("")
-    out.append("Pods:")
-    if not snap.pods:
-        out.append("  (no pods)")
-    else:
-        for p in snap.pods:
-            out.append(f"  - {p.name}: phase={p.phase}")
-
-    out.append("")
-    out.append("Deployments:")
-    if not snap.deployments:
-        out.append("  (no deployments)")
-    else:
-        for d in snap.deployments:
-            out.append(f"  - {d.name}: replicas={d.replicas}, ready={d.ready}")
-
-    out.append("")
-    out.append("CronJobs:")
-    if not snap.cronjobs:
-        out.append("  (no cronjobs)")
-    else:
-        for c in snap.cronjobs:
-            last = c.last_schedule or "never"
-            out.append(f"  - {c.name}: active={c.active}, lastScheduleTime={last}")
-
-    return "\n".join(out)
-
-
-# ---------------------------------------------------------------------
-# Logs System
-# ---------------------------------------------------------------------
-
-def _colorize_logs(text: str) -> str:
-    if not text:
-        return "<span style='color:#888;'>No logs</span>"
-
-    html_lines = []
-    for line in text.splitlines():
-        if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
-            color = "#ff4b4b"
-        elif re.search(r"warn", line, re.IGNORECASE):
-            color = "#f7c843"
-        elif re.search(r"(info|started|running|completed)", line, re.IGNORECASE):
-            color = "#5ad55a"
-        else:
-            color = "#d0d0d0"
-
-        safe = line.replace("<", "&lt;").replace(">", "&gt;")
-        html_lines.append(f"<span style='color:{color};'>{safe}</span>")
-
-    return "<br>".join(html_lines)
-
-
-def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
-    pod_name = pod_name.strip()
-    if not pod_name:
-        return "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
-
-    client = _get_client()
-    raw = client.get_pod_logs(pod_name, tail_lines)
-    return _colorize_logs(raw)
-
-
-def follow_pod_logs(pod_name: str, tail_lines: int):
-    pod_name = pod_name.strip()
-    if not pod_name:
-        yield "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
-        return
-
-    client = _get_client()
+def follow_logs(pod_name: str, tail: int):
+    """Streaming generator for follow logs."""
     while True:
-        raw = client.get_pod_logs(pod_name, tail_lines)
-        yield _colorize_logs(raw)
+        html = get_logs_once(pod_name, tail)
+        yield html
         time.sleep(2)
 
 
-# ---------------------------------------------------------------------
-# Logs CSS
-# ---------------------------------------------------------------------
-
-TERMINAL_CSS = """
-#logs_terminal {
-    background-color: #111;
-    color: #ddd;
-    font-family: monospace;
-    padding: 14px;
-    border-radius: 8px;
-    border: 1px solid #444;
-    height: 420px;
-    overflow-y: scroll;
-    white-space: pre-wrap;
-}
-"""
+# -------------------------------------------------------------------
+# Gradio UI
+# -------------------------------------------------------------------
 
+def build_ui():
+    with gr.Blocks(title="AgentCTL Frontend (FastAPI Backend)") as ui:
 
-# ---------------------------------------------------------------------
-# UI
-# ---------------------------------------------------------------------
+        gr.Markdown(f"""
+# 🚀 AgentCTL (Frontend)
+FastAPI Backend URL in use:
 
-def build_app() -> gr.Blocks:
-    with gr.Blocks(
-        title="AgentCTL: LLM-Driven Kubernetes Automation",
-        css=TERMINAL_CSS,
-    ) as demo:
+### **🔗 {BACKEND_URL}**
+
+_(Set AGENTCTL_BACKEND_URL environment variable to override)_
 
-        gr.Markdown("""
-### 🔧 Environment
-- `K8S_API_BASE_URL`  
-- `K8S_NAMESPACE`  
-- `K8S_VERIFY_SSL`  
-- `OPENAI_API_KEY` (optional)
 ---
 """)
 
-        # Create Resource
+        # ----------------------------------------------------------
+        # TAB 1 — Create Resource
+        # ----------------------------------------------------------
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
-                    label="Describe the resource",
+                    label="Describe your resource",
+                    lines=5,
                     placeholder=(
-                        "- run a python job\n"
+                        "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"
-                    ),
-                    lines=5,
+                    )
                 )
 
                 with gr.Column():
                     namespace = gr.Textbox(
                         label="Namespace",
-                        value=settings.k8s_namespace,
+                        value="default"
                     )
                     kind = gr.Dropdown(
-                        label="Resource kind",
+                        label="Kind",
                         choices=["Auto", "Job", "Deployment", "CronJob"],
-                        value="Auto",
+                        value="Auto"
                     )
 
             generate_btn = gr.Button("Generate YAML", variant="primary")
-            yaml_box = gr.Code(language="yaml", lines=22, label="Generated YAML")
+            yaml_box = gr.Code(label="Generated YAML", language="yaml")
 
-            apply_btn = gr.Button("Apply to cluster")
-            apply_msg = gr.Textbox(label="Status")
-            apply_debug = gr.Textbox(label="Raw API Response")
+            apply_btn = gr.Button("Apply YAML to Cluster", variant="primary")
+            apply_status = gr.Textbox(label="Status")
+            apply_raw = gr.Textbox(label="Raw API Response")
 
             generate_btn.click(
-                generate_yaml_from_prompt,
+                fn=generate_yaml,
                 inputs=[prompt, namespace, kind],
-                outputs=yaml_box,
+                outputs=yaml_box
             )
+
             apply_btn.click(
-                apply_yaml_to_cluster,
+                fn=apply_yaml,
                 inputs=[yaml_box],
-                outputs=[apply_msg, apply_debug],
+                outputs=[apply_status, apply_raw]
             )
 
-        # Dashboard
+        # ----------------------------------------------------------
+        # TAB 2 — Dashboard
+        # ----------------------------------------------------------
         with gr.Tab("Cluster Dashboard"):
-            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
-            snapshot_box = gr.Textbox(lines=25, label="Cluster Overview")
+            refresh_button = gr.Button("Refresh Snapshot", variant="primary")
+            snapshot_box = gr.Textbox(label="Cluster Snapshot", lines=25)
 
-            snapshot_btn.click(
-                get_cluster_snapshot,
-                inputs=[],
-                outputs=snapshot_box,
-            )
+            refresh_button.click(fn=get_snapshot, outputs=snapshot_box)
 
-        # Logs
+        # ----------------------------------------------------------
+        # TAB 3 — Pods Logs
+        # ----------------------------------------------------------
         with gr.Tab("Pod Logs"):
-            pod_name = gr.Textbox(label="Pod name")
-            tail_lines = gr.Slider(10, 500, step=10, value=100, label="Tail lines")
-
-            get_logs_btn = gr.Button("Get logs once")
-            follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
+            pod_name = gr.Textbox(label="Pod Name")
+            tail_lines = gr.Slider(
+                label="Tail Lines",
+                minimum=10,
+                maximum=500,
+                value=100
+            )
 
-            logs_box = gr.HTML(elem_id="logs_terminal", label="Logs")
+            get_logs_btn = gr.Button("Get Logs")
+            follow_logs_btn = gr.Button("Follow Logs (Live)", variant="primary")
+            logs_html = gr.HTML(label="Logs Terminal")
 
             get_logs_btn.click(
-                get_pod_logs_once,
+                fn=get_logs_once,
                 inputs=[pod_name, tail_lines],
-                outputs=logs_box,
+                outputs=logs_html
             )
 
-            # FIXED: removed `stream=True`
             follow_logs_btn.click(
-                follow_pod_logs,
+                fn=follow_logs,
                 inputs=[pod_name, tail_lines],
-                outputs=logs_box,
+                outputs=logs_html
             )
 
-    return demo
+    return ui
 
 
-app = build_app()
+# Build UI
+app = build_ui()
 
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", "7860"))
-    app.launch(server_name="0.0.0.0", server_port=port)
+    app.launch(server_name="0.0.0.0", server_port=7860)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/main.py

@@ -9,22 +9,24 @@ app = FastAPI(
     description="Backend API for Kubernetes AgentCTL automation",
 )
 
-# CORS (UI → API)
+# CORS (for Gradio UI, HF Space, other tools)
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # tighten later if needed
+    allow_origins=["*"],  # tighten later for prod
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Routers
-app.include_router(yaml_gen.router)
-app.include_router(apply.router)
-app.include_router(snapshot.router)
-app.include_router(logs.router)
 
-
-@app.get("/")
+@app.get("/", tags=["Status"])
 def root():
+    """Simple health endpoint."""
     return {"status": "AgentCTL Backend Running"}
+
+
+# Attach routers under /api/*
+app.include_router(yaml_gen.router, prefix="/api")
+app.include_router(apply.router, prefix="/api")
+app.include_router(snapshot.router, prefix="/api")
+app.include_router(logs.router, prefix="/api")

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/apply.py

@@ -1,37 +1,88 @@
+# backend/routers/apply.py
+
 from fastapi import APIRouter
 from pydantic import BaseModel
-import uuid, yaml
+import uuid
+import yaml
 
 from agentctl.k8s_client import K8sClient
 
-router = APIRouter(prefix="/api", tags=["Apply"])
+router = APIRouter(tags=["Apply Manifest"])
 
-client = K8sClient()
 
 class ApplyRequest(BaseModel):
     yaml: str
 
+
 class ApplyResponse(BaseModel):
     success: bool
     message: str
-    raw: str
+    raw: str | None = None
+
 
-def inject_unique(yaml_text: str) -> str:
+def _inject_unique_name(yaml_text: str) -> str:
+    """
+    Add a short UUID suffix to metadata.name for Job/CronJob/Deployment
+    to avoid 409 AlreadyExists errors when users re-apply the same YAML.
+    """
     try:
-        obj = yaml.safe_load(yaml_text)
-        kind = obj.get("kind")
+        data = yaml.safe_load(yaml_text)
+        if not isinstance(data, dict):
+            return yaml_text
+
+        kind = data.get("kind")
+        if kind not in {"Job", "CronJob", "Deployment"}:
+            return yaml_text
+
+        meta = data.get("metadata") or {}
+        base_name = meta.get("name")
+        if not base_name:
+            return yaml_text
+
+        suffix = str(uuid.uuid4())[:5]
+        new_name = f"{base_name}-{suffix}"
+        meta["name"] = new_name
+        data["metadata"] = meta
 
-        if kind in ["Job", "CronJob", "Deployment"]:
-            suffix = str(uuid.uuid4())[:5]
-            obj["metadata"]["name"] += f"-{suffix}"
+        # For CronJob make sure template labels are consistent
+        if kind == "CronJob":
+            tmpl = (
+                data.get("spec", {})
+                .get("jobTemplate", {})
+                .get("spec", {})
+                .get("template", {})
+            )
+            if isinstance(tmpl, dict):
+                md = tmpl.get("metadata") or {}
+                labels = md.get("labels") or {}
+                labels["app"] = new_name
+                md["labels"] = labels
+                tmpl["metadata"] = md
 
-        return yaml.safe_dump(obj)
-    except:
+        return yaml.safe_dump(data)
+    except Exception:
+        # on failure, just return original yaml
         return yaml_text
 
+
 @router.post("/apply", response_model=ApplyResponse)
-def apply_resource(req: ApplyRequest):
-    final_yaml = inject_unique(req.yaml)
+def apply_manifest(req: ApplyRequest):
+    """
+    Apply a YAML manifest to the Kubernetes cluster via K8sClient.
+    """
+    # Lazy K8sClient instantiation so missing env vars don't crash import
+    client = K8sClient()
+
+    final_yaml = _inject_unique_name(req.yaml)
     result = client.apply_manifest(final_yaml)
-    raw = str(result.raw_response)
-    return ApplyResponse(success=result.success, message=result.message, raw=raw)
+
+    try:
+        raw_str = str(result.raw_response)
+    except Exception:
+        raw_str = None
+
+    return ApplyResponse(
+        success=result.success,
+        message=result.message,
+        raw=raw_str,
+    )

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/logs.py

@@ -1,11 +1,20 @@
-from fastapi import APIRouter
+# backend/routers/logs.py
+
+from fastapi import APIRouter, Query
+
 from agentctl.k8s_client import K8sClient
 
-router = APIRouter(prefix="/api", tags=["Logs"])
+router = APIRouter(tags=["Logs"])
 
-client = K8sClient()
 
 @router.get("/logs")
-def get_logs(pod_name: str, tail: int = 100):
-    logs = client.get_pod_logs(pod_name, tail)
-    return {"pod": pod_name, "tail": tail, "logs": logs}
+def get_logs(
+    pod_name: str = Query(..., description="Pod name from snapshot"),
+    tail: int = Query(100, ge=1, le=1000, description="Tail lines"),
+):
+    """
+    Return raw logs for a given pod (no HTML, just plain text).
+    """
+    client = K8sClient()
+    text = client.get_pod_logs(pod_name.strip(), tail_lines=tail)
+    return {"pod_name": pod_name, "tail": tail, "logs": text}

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/snapshot.py

@@ -1,19 +1,54 @@
+# backend/routers/snapshot.py
+
 from fastapi import APIRouter
+
 from agentctl.k8s_client import K8sClient
 
-router = APIRouter(prefix="/api", tags=["Snapshot"])
+router = APIRouter(tags=["Cluster Snapshot"])
 
-client = K8sClient()
 
 @router.get("/snapshot")
-def snapshot():
+def get_snapshot():
+    """
+    Return a JSON snapshot of Jobs, Pods, Deployments, CronJobs in the namespace.
+    """
+    client = K8sClient()
     snap = client.snapshot()
 
-    data = {
-        "namespace": snap.namespace,
-        "jobs": [vars(j) for j in snap.jobs],
-        "pods": [vars(p) for p in snap.pods],
-        "deployments": [vars(d) for d in snap.deployments],
-        "cronjobs": [vars(c) for c in snap.cronjobs],
+    def job_to_dict(j):
+        return {
+            "name": getattr(j, "name", None),
+            "succeeded": getattr(j, "succeeded", None),
+            "failed": getattr(j, "failed", None),
+            "active": getattr(j, "active", None),
+        }
+
+    def pod_to_dict(p):
+        return {
+            "name": getattr(p, "name", None),
+            "phase": getattr(p, "phase", None),
+        }
+
+    def deploy_to_dict(d):
+        return {
+            "name": getattr(d, "name", None),
+            "replicas": getattr(d, "replicas", None),
+            "ready": getattr(d, "ready", None),
+        }
+
+    def cron_to_dict(c):
+        return {
+            "name": getattr(c, "name", None),
+            "active": getattr(c, "active", None),
+            # your schema likely calls this last_schedule or lastScheduleTime
+            "last_schedule": getattr(c, "last_schedule", None)
+            or getattr(c, "lastScheduleTime", None),
+        }
+
+    return {
+        "namespace": getattr(snap, "namespace", None),
+        "jobs": [job_to_dict(j) for j in snap.jobs],
+        "pods": [pod_to_dict(p) for p in snap.pods],
+        "deployments": [deploy_to_dict(d) for d in snap.deployments],
+        "cronjobs": [cron_to_dict(c) for c in snap.cronjobs],
     }
-    return data

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/yaml_gen.py

@@ -1,23 +1,39 @@
+# backend/routers/yaml_gen.py
+
 from fastapi import APIRouter
 from pydantic import BaseModel
+
 from agentctl.agent import K8sAgent
 from agentctl.config import settings
 
-router = APIRouter(prefix="/api", tags=["YAML Generation"])
+router = APIRouter(tags=["YAML Generation"])
 
 agent = K8sAgent()
 
-class GenerateRequest(BaseModel):
+
+class GenerateYAMLRequest(BaseModel):
     prompt: str
     namespace: str | None = None
     kind: str | None = "Auto"
 
-class GenerateResponse(BaseModel):
+
+class GenerateYAMLResponse(BaseModel):
     yaml: str
 
-@router.post("/generate-yaml", response_model=GenerateResponse)
-def generate_yaml(req: GenerateRequest):
+
+@router.post("/generate-yaml", response_model=GenerateYAMLResponse)
+def generate_yaml(req: GenerateYAMLRequest):
+    """
+    Natural language → Kubernetes YAML using your K8sAgent.
+    """
     ns = req.namespace or settings.k8s_namespace
-    kind = None if req.kind == "Auto" else req.kind
-    _, yaml_text = agent.nl_to_resource_yaml(req.prompt, ns, kind)
-    return GenerateResponse(yaml=yaml_text)
+    kind_sel = None if (req.kind is None or req.kind == "Auto") else req.kind
+
+    # your existing agent logic returns (explanation, yaml_text)
+    _, yaml_text = agent.nl_to_resource_yaml(
+        req.prompt,
+        namespace=ns,
+        kind=kind_sel,
+    )
+
+    return GenerateYAMLResponse(yaml=yaml_text)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/main.py

@@ -0,0 +1,30 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from backend.routers import yaml_gen, apply, snapshot, logs
+
+app = FastAPI(
+    title="AgentCTL Backend API",
+    version="1.0.0",
+    description="Backend API for Kubernetes AgentCTL automation",
+)
+
+# CORS (UI → API)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # tighten later if needed
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Routers
+app.include_router(yaml_gen.router)
+app.include_router(apply.router)
+app.include_router(snapshot.router)
+app.include_router(logs.router)
+
+
+@app.get("/")
+def root():
+    return {"status": "AgentCTL Backend Running"}

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/apply.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+import uuid, yaml
+
+from agentctl.k8s_client import K8sClient
+
+router = APIRouter(prefix="/api", tags=["Apply"])
+
+client = K8sClient()
+
+class ApplyRequest(BaseModel):
+    yaml: str
+
+class ApplyResponse(BaseModel):
+    success: bool
+    message: str
+    raw: str
+
+def inject_unique(yaml_text: str) -> str:
+    try:
+        obj = yaml.safe_load(yaml_text)
+        kind = obj.get("kind")
+
+        if kind in ["Job", "CronJob", "Deployment"]:
+            suffix = str(uuid.uuid4())[:5]
+            obj["metadata"]["name"] += f"-{suffix}"
+
+        return yaml.safe_dump(obj)
+    except:
+        return yaml_text
+
+@router.post("/apply", response_model=ApplyResponse)
+def apply_resource(req: ApplyRequest):
+    final_yaml = inject_unique(req.yaml)
+    result = client.apply_manifest(final_yaml)
+    raw = str(result.raw_response)
+    return ApplyResponse(success=result.success, message=result.message, raw=raw)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/logs.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+from agentctl.k8s_client import K8sClient
+
+router = APIRouter(prefix="/api", tags=["Logs"])
+
+client = K8sClient()
+
+@router.get("/logs")
+def get_logs(pod_name: str, tail: int = 100):
+    logs = client.get_pod_logs(pod_name, tail)
+    return {"pod": pod_name, "tail": tail, "logs": logs}

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/snapshot.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter
+from agentctl.k8s_client import K8sClient
+
+router = APIRouter(prefix="/api", tags=["Snapshot"])
+
+client = K8sClient()
+
+@router.get("/snapshot")
+def snapshot():
+    snap = client.snapshot()
+
+    data = {
+        "namespace": snap.namespace,
+        "jobs": [vars(j) for j in snap.jobs],
+        "pods": [vars(p) for p in snap.pods],
+        "deployments": [vars(d) for d in snap.deployments],
+        "cronjobs": [vars(c) for c in snap.cronjobs],
+    }
+    return data

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/routers/yaml_gen.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from agentctl.agent import K8sAgent
+from agentctl.config import settings
+
+router = APIRouter(prefix="/api", tags=["YAML Generation"])
+
+agent = K8sAgent()
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    namespace: str | None = None
+    kind: str | None = "Auto"
+
+class GenerateResponse(BaseModel):
+    yaml: str
+
+@router.post("/generate-yaml", response_model=GenerateResponse)
+def generate_yaml(req: GenerateRequest):
+    ns = req.namespace or settings.k8s_namespace
+    kind = None if req.kind == "Auto" else req.kind
+    _, yaml_text = agent.nl_to_resource_yaml(req.prompt, ns, kind)
+    return GenerateResponse(yaml=yaml_text)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/services/agent_service.py

@@ -0,0 +1,29 @@
+from agentctl.agent import K8sAgent
+from agentctl.config import settings
+
+
+class AgentService:
+    """
+    Wrapper for the LLM → YAML agent.
+    """
+
+    def __init__(self):
+        self.agent = K8sAgent()
+
+    def generate_yaml(self, prompt: str, namespace: str | None, kind: str | None):
+        # fallback to default namespace from config
+        ns = namespace or settings.k8s_namespace
+        kind_sel = None if (kind is None or kind == "Auto") else kind
+
+        # returns: (explanation, yaml_text)
+        _, yaml_text = self.agent.nl_to_resource_yaml(
+            prompt,
+            namespace=ns,
+            kind=kind_sel,
+        )
+
+        return yaml_text
+
+
+# Shared singleton
+agent_service = AgentService()

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/backend/services/k8s_service.py

@@ -0,0 +1,28 @@
+from agentctl.k8s_client import K8sClient
+
+
+class K8sService:
+    """
+    Simple wrapper around your existing K8sClient.
+    This allows FastAPI routes to call Kubernetes operations
+    without importing K8sClient directly in every router.
+    """
+
+    def __init__(self):
+        self.client = K8sClient()
+
+    # ---- Apply YAML ----
+    def apply_manifest(self, yaml_text: str):
+        return self.client.apply_manifest(yaml_text)
+
+    # ---- Snapshot ----
+    def snapshot(self):
+        return self.client.snapshot()
+
+    # ---- Logs ----
+    def get_pod_logs(self, pod_name: str, tail_lines: int = 100):
+        return self.client.get_pod_logs(pod_name, tail_lines=tail_lines)
+
+
+# Shared singleton instance
+k8s_service = K8sService()

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -81,7 +81,6 @@ def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
     if not yaml_text.strip():
         return "No YAML to apply.", ""
 
-    # Add unique suffix before applying
     yaml_text = _inject_unique_name(yaml_text)
 
     client = _get_client()
@@ -229,9 +228,7 @@ def build_app() -> gr.Blocks:
 ---
 """)
 
-        # -----------------------------------------------------------------
         # Create Resource
-        # -----------------------------------------------------------------
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
@@ -273,9 +270,7 @@ def build_app() -> gr.Blocks:
                 outputs=[apply_msg, apply_debug],
             )
 
-        # -----------------------------------------------------------------
         # Dashboard
-        # -----------------------------------------------------------------
         with gr.Tab("Cluster Dashboard"):
             snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
             snapshot_box = gr.Textbox(lines=25, label="Cluster Overview")
@@ -286,9 +281,7 @@ def build_app() -> gr.Blocks:
                 outputs=snapshot_box,
             )
 
-        # -----------------------------------------------------------------
         # Logs
-        # -----------------------------------------------------------------
         with gr.Tab("Pod Logs"):
             pod_name = gr.Textbox(label="Pod name")
             tail_lines = gr.Slider(10, 500, step=10, value=100, label="Tail lines")
@@ -304,11 +297,11 @@ def build_app() -> gr.Blocks:
                 outputs=logs_box,
             )
 
+            # FIXED: removed `stream=True`
             follow_logs_btn.click(
                 follow_pod_logs,
                 inputs=[pod_name, tail_lines],
                 outputs=logs_box,
-                stream=True,
             )
 
     return demo

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 
 import os
+import re
+import time
+import uuid
+import yaml
 from typing import Tuple
 
 import gradio as gr
@@ -10,26 +14,66 @@ from agentctl.k8s_client import K8sClient
 from agentctl.agent import K8sAgent
 
 
-agent = K8sAgent()
+# ---------------------------------------------------------------------
+# Core - Agent + Client
+# ---------------------------------------------------------------------
 
+agent = K8sAgent()
 
 def _get_client() -> K8sClient:
     return K8sClient()
 
 
-# ------------------------------------------------------------
-# Handlers
-# ------------------------------------------------------------
+# ---------------------------------------------------------------------
+# Unique Name Injection
+# ---------------------------------------------------------------------
+
+def _inject_unique_name(yaml_text: str) -> str:
+    """
+    Add unique suffix to metadata.name for Job, Deployment, CronJob.
+    Prevents 409 AlreadyExists errors.
+    """
+    try:
+        data = yaml.safe_load(yaml_text)
+        if not isinstance(data, dict):
+            return yaml_text
+
+        kind = data.get("kind")
+        if kind not in {"Job", "CronJob", "Deployment"}:
+            return yaml_text
+
+        base = data["metadata"]["name"]
+        suffix = str(uuid.uuid4())[:5]
+        new_name = f"{base}-{suffix}"
+        data["metadata"]["name"] = new_name
+
+        # Patch CronJob template labels
+        if kind == "CronJob":
+            jt = data["spec"]["jobTemplate"]["spec"]["template"]
+            if "metadata" in jt:
+                if "labels" in jt["metadata"]:
+                    jt["metadata"]["labels"]["app"] = new_name
+                else:
+                    jt["metadata"]["labels"] = {"app": new_name}
+
+        return yaml.safe_dump(data)
+
+    except Exception:
+        return yaml_text
 
 
+# ---------------------------------------------------------------------
+# YAML Generation + Apply
+# ---------------------------------------------------------------------
+
 def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
     if not prompt.strip():
         return "# Enter a description, e.g. 'run a python preprocessing job'"
-    _, yaml_text = agent.nl_to_resource_yaml(
-        prompt,
-        namespace=namespace or settings.k8s_namespace,
-        kind=kind if kind != "Auto" else None,
-    )
+
+    ns = namespace.strip() or settings.k8s_namespace
+    kind_sel = None if kind == "Auto" else kind
+
+    _, yaml_text = agent.nl_to_resource_yaml(prompt, namespace=ns, kind=kind_sel)
     return yaml_text
 
 
@@ -37,118 +81,173 @@ def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
     if not yaml_text.strip():
         return "No YAML to apply.", ""
 
+    # Add unique suffix before applying
+    yaml_text = _inject_unique_name(yaml_text)
+
     client = _get_client()
     result = client.apply_manifest(yaml_text)
 
-    if result.success:
-        return result.message, (result.raw_response and str(result.raw_response) or "")
-    else:
-        return f"❌ {result.message}", (result.raw_response and str(result.raw_response) or "")
+    try:
+        raw = str(result.raw_response)
+    except:
+        raw = "<unserialisable>"
+
+    prefix = "✅" if result.success else "❌"
+    return f"{prefix} {result.message}", raw
 
 
+# ---------------------------------------------------------------------
+# Cluster Snapshot
+# ---------------------------------------------------------------------
+
 def get_cluster_snapshot() -> str:
     client = _get_client()
     snap = client.snapshot()
 
-    lines: list[str] = [f"Namespace: {snap.namespace}", ""]
+    out = [f"Namespace: {snap.namespace}", ""]
 
-    # Jobs
-    lines.append("Jobs:")
+    out.append("Jobs:")
     if not snap.jobs:
-        lines.append("  (no jobs)")
+        out.append("  (no jobs)")
     else:
         for j in snap.jobs:
-            lines.append(
+            out.append(
                 f"  - {j.name}: succeeded={j.succeeded}, failed={j.failed}, active={j.active}"
             )
 
-    # Pods
-    lines.append("")
-    lines.append("Pods:")
+    out.append("")
+    out.append("Pods:")
     if not snap.pods:
-        lines.append("  (no pods)")
+        out.append("  (no pods)")
     else:
         for p in snap.pods:
-            lines.append(f"  - {p.name}: phase={p.phase}")
+            out.append(f"  - {p.name}: phase={p.phase}")
 
-    # Deployments
-    lines.append("")
-    lines.append("Deployments:")
+    out.append("")
+    out.append("Deployments:")
     if not snap.deployments:
-        lines.append("  (no deployments)")
+        out.append("  (no deployments)")
     else:
         for d in snap.deployments:
-            lines.append(
-                f"  - {d.name}: replicas={d.replicas}, ready={d.ready}"
-            )
+            out.append(f"  - {d.name}: replicas={d.replicas}, ready={d.ready}")
 
-    # CronJobs
-    lines.append("")
-    lines.append("CronJobs:")
+    out.append("")
+    out.append("CronJobs:")
     if not snap.cronjobs:
-        lines.append("  (no cronjobs)")
+        out.append("  (no cronjobs)")
     else:
         for c in snap.cronjobs:
             last = c.last_schedule or "never"
-            lines.append(
-                f"  - {c.name}: active={c.active}, lastScheduleTime={last}"
-            )
+            out.append(f"  - {c.name}: active={c.active}, lastScheduleTime={last}")
+
+    return "\n".join(out)
+
+
+# ---------------------------------------------------------------------
+# Logs System
+# ---------------------------------------------------------------------
+
+def _colorize_logs(text: str) -> str:
+    if not text:
+        return "<span style='color:#888;'>No logs</span>"
+
+    html_lines = []
+    for line in text.splitlines():
+        if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
+            color = "#ff4b4b"
+        elif re.search(r"warn", line, re.IGNORECASE):
+            color = "#f7c843"
+        elif re.search(r"(info|started|running|completed)", line, re.IGNORECASE):
+            color = "#5ad55a"
+        else:
+            color = "#d0d0d0"
+
+        safe = line.replace("<", "&lt;").replace(">", "&gt;")
+        html_lines.append(f"<span style='color:{color};'>{safe}</span>")
+
+    return "<br>".join(html_lines)
 
-    return "\n".join(lines)
 
+def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
+    pod_name = pod_name.strip()
+    if not pod_name:
+        return "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
 
-def get_pod_logs_handler(pod_name: str, tail_lines: int) -> str:
-    if not pod_name.strip():
-        return "Enter a pod name from the snapshot above."
     client = _get_client()
-    logs = client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
-    return logs
+    raw = client.get_pod_logs(pod_name, tail_lines)
+    return _colorize_logs(raw)
 
 
-# ------------------------------------------------------------
-# Gradio UI
-# ------------------------------------------------------------
+def follow_pod_logs(pod_name: str, tail_lines: int):
+    pod_name = pod_name.strip()
+    if not pod_name:
+        yield "<span style='color:#ff4b4b;'>Enter a pod name.</span>"
+        return
 
+    client = _get_client()
+    while True:
+        raw = client.get_pod_logs(pod_name, tail_lines)
+        yield _colorize_logs(raw)
+        time.sleep(2)
+
+
+# ---------------------------------------------------------------------
+# Logs CSS
+# ---------------------------------------------------------------------
+
+TERMINAL_CSS = """
+#logs_terminal {
+    background-color: #111;
+    color: #ddd;
+    font-family: monospace;
+    padding: 14px;
+    border-radius: 8px;
+    border: 1px solid #444;
+    height: 420px;
+    overflow-y: scroll;
+    white-space: pre-wrap;
+}
+"""
+
+
+# ---------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------
 
 def build_app() -> gr.Blocks:
-    with gr.Blocks(title="AgentCTL: LLM-Driven Kubernetes Automation") as demo:
-        gr.Markdown(
-            """
-            # AgentCTL: LLM-Driven Kubernetes Automation
-
-            This Space connects to a **real Kubernetes cluster** (e.g. Minikube
-            exposed via `kubectl proxy` + ngrok). It demonstrates an
-            **agentic workflow** where natural language is converted into
-            Kubernetes Job / Deployment / CronJob manifests.
-
-            Environment variables:
-
-            - `K8S_API_BASE_URL` → public K8s API URL (ngrok over `kubectl proxy`)
-            - `K8S_NAMESPACE`    → default namespace
-            - `K8S_VERIFY_SSL`   → true/false
-            - `AGENTCTL_USE_LLM` → true/false (optional; uses OpenAI if enabled)
-            - `OPENAI_API_KEY`   → your key (if LLM enabled)
-            """
-        )
-
-        # --------- Create Resource tab --------- #
+    with gr.Blocks(
+        title="AgentCTL: LLM-Driven Kubernetes Automation",
+        css=TERMINAL_CSS,
+    ) as demo:
+
+        gr.Markdown("""
+### 🔧 Environment
+- `K8S_API_BASE_URL`  
+- `K8S_NAMESPACE`  
+- `K8S_VERIFY_SSL`  
+- `OPENAI_API_KEY` (optional)
+---
+""")
+
+        # -----------------------------------------------------------------
+        # Create Resource
+        # -----------------------------------------------------------------
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
-                    label="Describe the resource you want",
+                    label="Describe the resource",
                     placeholder=(
-                        "Examples:\n"
-                        "- run a python job to preprocess data\n"
+                        "- run a python job\n"
                         "- create an nginx deployment with 3 replicas\n"
-                        "- schedule a python cleanup job every 5 minutes\n"
+                        "- schedule a cleanup script every 5 minutes\n"
                     ),
                     lines=5,
                 )
+
                 with gr.Column():
                     namespace = gr.Textbox(
-                        label="Kubernetes namespace",
+                        label="Namespace",
                         value=settings.k8s_namespace,
-                        lines=1,
                     )
                     kind = gr.Dropdown(
                         label="Resource kind",
@@ -156,50 +255,60 @@ def build_app() -> gr.Blocks:
                         value="Auto",
                     )
 
-            generate_btn = gr.Button("Generate YAML")
-            yaml_box = gr.Code(label="Generated Manifest (YAML)", language="yaml", lines=22)
+            generate_btn = gr.Button("Generate YAML", variant="primary")
+            yaml_box = gr.Code(language="yaml", lines=22, label="Generated YAML")
 
-            apply_btn = gr.Button("Apply to Cluster")
-            apply_msg = gr.Textbox(label="Status", interactive=False)
-            apply_raw = gr.Textbox(label="Raw API response (debug)")
+            apply_btn = gr.Button("Apply to cluster")
+            apply_msg = gr.Textbox(label="Status")
+            apply_debug = gr.Textbox(label="Raw API Response")
 
             generate_btn.click(
-                fn=generate_yaml_from_prompt,
+                generate_yaml_from_prompt,
                 inputs=[prompt, namespace, kind],
-                outputs=[yaml_box],
+                outputs=yaml_box,
             )
-
             apply_btn.click(
-                fn=apply_yaml_to_cluster,
+                apply_yaml_to_cluster,
                 inputs=[yaml_box],
-                outputs=[apply_msg, apply_raw],
+                outputs=[apply_msg, apply_debug],
             )
 
-        # --------- Dashboard tab --------- #
+        # -----------------------------------------------------------------
+        # Dashboard
+        # -----------------------------------------------------------------
         with gr.Tab("Cluster Dashboard"):
-            gr.Markdown("Snapshot of Jobs, Pods, Deployments and CronJobs in the namespace.")
-            snapshot_btn = gr.Button("Refresh snapshot")
-            snapshot_box = gr.Textbox(label="Cluster Overview", lines=25)
+            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
+            snapshot_box = gr.Textbox(lines=25, label="Cluster Overview")
 
-            snapshot_btn.click(fn=get_cluster_snapshot, inputs=[], outputs=[snapshot_box])
+            snapshot_btn.click(
+                get_cluster_snapshot,
+                inputs=[],
+                outputs=snapshot_box,
+            )
 
-        # --------- Pod Logs tab --------- #
+        # -----------------------------------------------------------------
+        # Logs
+        # -----------------------------------------------------------------
         with gr.Tab("Pod Logs"):
             pod_name = gr.Textbox(label="Pod name")
-            tail_lines = gr.Slider(
-                label="Tail lines",
-                minimum=10,
-                maximum=500,
-                step=10,
-                value=100,
+            tail_lines = gr.Slider(10, 500, step=10, value=100, label="Tail lines")
+
+            get_logs_btn = gr.Button("Get logs once")
+            follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
+
+            logs_box = gr.HTML(elem_id="logs_terminal", label="Logs")
+
+            get_logs_btn.click(
+                get_pod_logs_once,
+                inputs=[pod_name, tail_lines],
+                outputs=logs_box,
             )
-            logs_btn = gr.Button("Get logs")
-            logs_box = gr.Textbox(label="Logs", lines=25)
 
-            logs_btn.click(
-                fn=get_pod_logs_handler,
+            follow_logs_btn.click(
+                follow_pod_logs,
                 inputs=[pod_name, tail_lines],
-                outputs=[logs_box],
+                outputs=logs_box,
+                stream=True,
             )
 
     return demo
@@ -208,4 +317,5 @@ def build_app() -> gr.Blocks:
 app = build_app()
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))
+    port = int(os.getenv("PORT", "7860"))
+    app.launch(server_name="0.0.0.0", server_port=port)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/.github/workflows/sync-to-hf.yml

@@ -0,0 +1,39 @@
+name: Sync GitHub (master) → Hugging Face Space (main)
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Sync files to Hugging Face Space
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          echo "🔐 Configuring Git"
+          git config --global user.email "actions@github.com"
+          git config --global user.name "GitHub Actions"
+
+          echo "📥 Cloning Hugging Face Space repo"
+          git clone https://codeninja3d:${HF_TOKEN}@huggingface.co/spaces/codeninja3d/agentctl hf-space
+
+          echo "📤 Syncing GitHub files → HF Space (rsync)"
+          rsync -av --delete --exclude=".git" ./ hf-space/ || true
+
+          cd hf-space
+
+          echo "📌 Committing changes"
+          git add .
+          git commit -m "Sync from GitHub on master ($(date))" || echo "No changes"
+
+          echo "⬆️ Pushing to Hugging Face Space (main branch)"
+          git push https://codeninja3d:${HF_TOKEN}@huggingface.co/spaces/codeninja3d/agentctl HEAD:main
+
+          echo "🎉 Sync complete!"

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/README.md

@@ -1,16 +1,225 @@
 ---
-title: AgentCTL
-emoji: ⚙️
+title: AgentCTL – Kubernetes Agent UI
+emoji: 🧠
 colorFrom: blue
-colorTo: purple
+colorTo: green
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: "4.42.0"
 app_file: app.py
 pinned: false
 ---
 
 
-AgentCTL is a next-generation, agentic control plane for Kubernetes.
-It allows you to create, manage, and observe Kubernetes resources using natural language, backed by a minimal REST client and optional LLM-powered YAML generation.
+# AgentCTL — LLM-Driven Kubernetes Automation  
+### Natural Language → Kubernetes Jobs, Deployments & CronJobs  
+Built for real clusters via Minikube + kubectl proxy + ngrok or Cloudflare Tunnel.
 
-AgentCTL runs locally or can be deployed to Hugging Face Spaces, allowing cloud-hosted UI + locally hosted Kubernetes clusters.
+---
+
+## 🚀 Overview
+
+**AgentCTL** is an agentic workflow system that converts **natural language instructions** into **Kubernetes manifests** (Jobs, Deployments, CronJobs) and applies them to a **real Kubernetes cluster**.
+
+It works by exposing your cluster via:
+
+- `kubectl proxy`
+- a public tunnel (`ngrok` or `cloudflared`)
+- a Gradio web UI  
+- a lightweight NL → YAML agent (heuristic + optional OpenAI LLM)
+
+---
+
+## ✨ Features
+
+- Natural language → Kubernetes YAML  
+- Supports:
+  - Jobs
+  - Deployments
+  - CronJobs  
+- Optional OpenAI LLM YAML refinement  
+- Cluster dashboard (Jobs, Pods, Deployments, CronJobs)  
+- Pod logs viewer  
+- Pure HTTP client — no kubeconfig required  
+
+---
+
+## 🧱 Architecture
+
+```
+Gradio UI → AgentCTL (NL→YAML) → K8sClient (HTTP) → Kubernetes API
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+or
+
+```bash
+conda create -n agentctl python=3.10 -y
+conda activate agentctl
+pip install -r requirements.txt
+```
+
+---
+
+## 🧪 Minikube Setup
+
+```bash
+minikube start --driver=docker
+kubectl get pods -A
+```
+
+Expose API publicly:
+
+```bash
+kubectl proxy   --port=8001   --address=0.0.0.0   --accept-hosts='.*'   --accept-paths='.*'
+```
+
+Tunnel:
+
+```bash
+ngrok http 8001
+```
+
+---
+
+## 🌐 Environment Variables
+
+```bash
+export K8S_API_BASE_URL="https://xxxx.ngrok-free.dev"
+export K8S_NAMESPACE="default"
+export K8S_VERIFY_SSL=false
+```
+
+Enable LLM YAML:
+
+```bash
+export AGENTCTL_USE_LLM=true
+export OPENAI_API_KEY="sk-..."
+export OPENAI_MODEL="gpt-4o-mini"
+```
+
+---
+
+## ▶️ Run the App
+
+```bash
+python app.py
+```
+
+Open:
+
+```
+http://localhost:7860
+```
+
+---
+
+## 📝 Usage Examples
+
+### 🟦 Job
+```
+run a python job to preprocess data
+```
+
+### 🟧 Deployment
+```
+Prompt
+create an nginx deployment with 3 replicas
+
+Example
+**Generated YAML:**
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx-deployment
+  namespace: default
+  labels:
+    app: agentctl-deployment
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: agentctl-deployment
+  template:
+    metadata:
+      labels:
+        app: agentctl-deployment
+    spec:
+      containers:
+        - name: main
+          image: nginx:1.27-alpine
+          ports:
+            - containerPort: 80
+
+```
+
+### 🟩 CronJob
+```
+Prompt
+schedule a python cleanup script every 5 minutes
+
+example
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: agentctl-cronjob
+  namespace: default
+spec:
+  schedule: "*/5 * * * *"
+  jobTemplate:
+    spec:
+      template:
+        metadata:
+          labels:
+            app: agentctl-cronjob
+        spec:
+          restartPolicy: Never
+          containers:
+            - name: main
+              image: python:3.11-slim
+              command:
+                - /bin/sh
+                - -c
+                - python cleanup.py
+
+```
+
+---
+
+## 🚀 Deploy to Hugging Face Spaces
+
+1. Create a Space (Gradio)
+2. Upload project files
+3. Set environment variables
+4. Run the UI remotely controlling your real cluster
+
+---
+
+## 🔐 Security Notes
+
+- ngrok + kubectl proxy is for demos only  
+- For real environments use:
+  - Cloudflare Tunnel  
+  - RBAC service accounts  
+  - Namespaced permissions  
+
+---
+
+## ❤️ Credits
+
+Built by **Murali Chandran (codeninja3d)**  
+AI Agents • Kubernetes • MLOps
+
+---
+
+## 📄 License
+
+MIT License

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -1,8 +1,6 @@
 #!/usr/bin/env python3
 
 import os
-import re
-import time
 from typing import Tuple
 
 import gradio as gr
@@ -12,65 +10,43 @@ from agentctl.k8s_client import K8sClient
 from agentctl.agent import K8sAgent
 
 
-# ---------------------------------------------------------------------
-# Core objects
-# ---------------------------------------------------------------------
-
 agent = K8sAgent()
 
 
 def _get_client() -> K8sClient:
-    """Create a Kubernetes HTTP client using env-based config."""
     return K8sClient()
 
 
-# ---------------------------------------------------------------------
-# YAML generation + apply
-# ---------------------------------------------------------------------
+# ------------------------------------------------------------
+# Handlers
+# ------------------------------------------------------------
 
 
 def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
-    """Convert natural language + kind selection into YAML."""
     if not prompt.strip():
         return "# Enter a description, e.g. 'run a python preprocessing job'"
-
-    ns = namespace.strip() or settings.k8s_namespace
-    kind_sel = None if kind == "Auto" else kind
-
     _, yaml_text = agent.nl_to_resource_yaml(
         prompt,
-        namespace=ns,
-        kind=kind_sel,
+        namespace=namespace or settings.k8s_namespace,
+        kind=kind if kind != "Auto" else None,
     )
     return yaml_text
 
 
 def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
-    """Apply a YAML manifest to the cluster via K8s API."""
     if not yaml_text.strip():
         return "No YAML to apply.", ""
 
     client = _get_client()
     result = client.apply_manifest(yaml_text)
 
-    raw_str = ""
-    if result.raw_response is not None:
-        try:
-            raw_str = str(result.raw_response)
-        except Exception:
-            raw_str = "<unserialisable response>"
-
-    prefix = "✅" if result.success else "❌"
-    return f"{prefix} {result.message}", raw_str
-
-
-# ---------------------------------------------------------------------
-# Dashboard snapshot
-# ---------------------------------------------------------------------
+    if result.success:
+        return result.message, (result.raw_response and str(result.raw_response) or "")
+    else:
+        return f"❌ {result.message}", (result.raw_response and str(result.raw_response) or "")
 
 
 def get_cluster_snapshot() -> str:
-    """Return a human-readable snapshot of Jobs, Pods, Deployments, CronJobs."""
     client = _get_client()
     snap = client.snapshot()
 
@@ -83,8 +59,7 @@ def get_cluster_snapshot() -> str:
     else:
         for j in snap.jobs:
             lines.append(
-                f"  - {j.name}: succeeded={j.succeeded}, "
-                f"failed={j.failed}, active={j.active}"
+                f"  - {j.name}: succeeded={j.succeeded}, failed={j.failed}, active={j.active}"
             )
 
     # Pods
@@ -122,109 +97,41 @@ def get_cluster_snapshot() -> str:
     return "\n".join(lines)
 
 
-# ---------------------------------------------------------------------
-# Logs helpers (colorised terminal + live follow)
-# ---------------------------------------------------------------------
+def get_pod_logs_handler(pod_name: str, tail_lines: int) -> str:
+    if not pod_name.strip():
+        return "Enter a pod name from the snapshot above."
+    client = _get_client()
+    logs = client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
+    return logs
 
 
-def _fetch_pod_logs_raw(pod_name: str, tail_lines: int) -> str:
-    """Internal: raw log text from Kubernetes."""
-    client = _get_client()
-    return client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
-
-
-def _colorize_logs(text: str) -> str:
-    """Convert log text into HTML with basic severity colouring."""
-    if not text:
-        return "<span style='color:#888;'>No logs</span>"
-
-    lines = text.splitlines()
-    out: list[str] = []
-
-    for line in lines:
-        if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
-            colour = "#ff4b4b"  # red
-        elif re.search(r"(warn)", line, re.IGNORECASE):
-            colour = "#f7c843"  # yellow
-        elif re.search(r"(info|started|running|completed)", line, re.IGNORECASE):
-            colour = "#5ad55a"  # green
-        else:
-            colour = "#d0d0d0"  # grey
-
-        safe = line.replace("<", "&lt;").replace(">", "&gt;")
-        out.append(f"<span style='color:{colour};'>{safe}</span>")
-
-    return "<br>".join(out)
-
-
-def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
-    """One-shot logs fetch, used for the 'Get logs' button."""
-    pod_name = pod_name.strip()
-    if not pod_name:
-        return "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
-
-    raw = _fetch_pod_logs_raw(pod_name, tail_lines)
-    return _colorize_logs(raw)
-
-
-def follow_pod_logs(pod_name: str, tail_lines: int):
-    """Live streaming logs using Gradio generator output."""
-    pod_name = pod_name.strip()
-    if not pod_name:
-        yield "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
-        return
-
-    while True:
-        raw = _fetch_pod_logs_raw(pod_name, tail_lines)
-        html = _colorize_logs(raw)
-        yield html
-        time.sleep(2)
-
-
-# CSS for the logs "terminal"
-TERMINAL_CSS = """
-#logs_terminal {
-    background-color: #111111 !important;
-    color: #d0d0d0 !important;
-    font-family: monospace !important;
-    padding: 14px;
-    border-radius: 8px;
-    border: 1px solid #444444;
-    height: 420px;
-    overflow-y: scroll;
-    white-space: pre-wrap;
-}
-"""
-
-
-# ---------------------------------------------------------------------
+# ------------------------------------------------------------
 # Gradio UI
-# ---------------------------------------------------------------------
+# ------------------------------------------------------------
 
 
 def build_app() -> gr.Blocks:
-    with gr.Blocks(
-        title="AgentCTL: LLM-Driven Kubernetes Automation",
-        css=TERMINAL_CSS,
-    ) as demo:
-        # Top environment hint (like your screenshot)
+    with gr.Blocks(title="AgentCTL: LLM-Driven Kubernetes Automation") as demo:
         gr.Markdown(
             """
-### 🔧 Environment configuration
+            # AgentCTL: LLM-Driven Kubernetes Automation
+
+            This Space connects to a **real Kubernetes cluster** (e.g. Minikube
+            exposed via `kubectl proxy` + ngrok). It demonstrates an
+            **agentic workflow** where natural language is converted into
+            Kubernetes Job / Deployment / CronJob manifests.
 
-- `K8S_API_BASE_URL` → **public K8s API URL** (ngrok / Cloudflare tunnel over `kubectl proxy`)
-- `K8S_NAMESPACE` → **default namespace** (e.g. `default`)
-- `K8S_VERIFY_SSL` → **true/false** (set `false` for self-signed ngrok endpoints)
-- `AGENTCTL_USE_LLM` → **true/false** (optional; uses OpenAI if enabled in `agent.py`)
-- `OPENAI_API_KEY` → your key (if LLM mode enabled)
+            Environment variables:
 
----
-"""
+            - `K8S_API_BASE_URL` → public K8s API URL (ngrok over `kubectl proxy`)
+            - `K8S_NAMESPACE`    → default namespace
+            - `K8S_VERIFY_SSL`   → true/false
+            - `AGENTCTL_USE_LLM` → true/false (optional; uses OpenAI if enabled)
+            - `OPENAI_API_KEY`   → your key (if LLM enabled)
+            """
         )
 
-        # ============================================================
-        # Create Resource tab
-        # ============================================================
+        # --------- Create Resource tab --------- #
         with gr.Tab("Create Resource"):
             with gr.Row():
                 prompt = gr.Textbox(
@@ -237,7 +144,6 @@ def build_app() -> gr.Blocks:
                     ),
                     lines=5,
                 )
-
                 with gr.Column():
                     namespace = gr.Textbox(
                         label="Kubernetes namespace",
@@ -249,25 +155,18 @@ def build_app() -> gr.Blocks:
                         choices=["Auto", "Job", "Deployment", "CronJob"],
                         value="Auto",
                     )
-                    gr.Markdown(
-                        "Tip: leave **Auto** to let the agent infer Job vs Deployment vs CronJob."
-                    )
 
-            generate_btn = gr.Button("Generate YAML", variant="primary")
-            yaml_box = gr.Code(
-                label="Generated manifest (YAML)",
-                language="yaml",
-                lines=22,
-            )
+            generate_btn = gr.Button("Generate YAML")
+            yaml_box = gr.Code(label="Generated Manifest (YAML)", language="yaml", lines=22)
 
-            apply_btn = gr.Button("Apply to cluster")
+            apply_btn = gr.Button("Apply to Cluster")
             apply_msg = gr.Textbox(label="Status", interactive=False)
             apply_raw = gr.Textbox(label="Raw API response (debug)")
 
             generate_btn.click(
                 fn=generate_yaml_from_prompt,
                 inputs=[prompt, namespace, kind],
-                outputs=yaml_box,
+                outputs=[yaml_box],
             )
 
             apply_btn.click(
@@ -276,39 +175,17 @@ def build_app() -> gr.Blocks:
                 outputs=[apply_msg, apply_raw],
             )
 
-        # ============================================================
-        # Cluster Dashboard tab
-        # ============================================================
+        # --------- Dashboard tab --------- #
         with gr.Tab("Cluster Dashboard"):
-            gr.Markdown(
-                "Snapshot of **Jobs, Pods, Deployments, CronJobs** in the target namespace."
-            )
-            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
-            snapshot_box = gr.Textbox(
-                label="Cluster overview",
-                lines=25,
-                interactive=False,
-            )
+            gr.Markdown("Snapshot of Jobs, Pods, Deployments and CronJobs in the namespace.")
+            snapshot_btn = gr.Button("Refresh snapshot")
+            snapshot_box = gr.Textbox(label="Cluster Overview", lines=25)
 
-            snapshot_btn.click(
-                fn=get_cluster_snapshot,
-                inputs=[],
-                outputs=[snapshot_box],
-            )
+            snapshot_btn.click(fn=get_cluster_snapshot, inputs=[], outputs=[snapshot_box])
 
-        # ============================================================
-        # Pod Logs tab
-        # ============================================================
+        # --------- Pod Logs tab --------- #
         with gr.Tab("Pod Logs"):
-            gr.Markdown(
-                "Paste a pod name from the **Cluster Dashboard** (e.g. `agentctl-job-lnrcp`) "
-                "and fetch its logs. Use **Follow logs** for a live `kubectl logs -f` style view."
-            )
-
-            pod_name = gr.Textbox(
-                label="Pod name",
-                placeholder="e.g. preprocess-job-z48rz",
-            )
+            pod_name = gr.Textbox(label="Pod name")
             tail_lines = gr.Slider(
                 label="Tail lines",
                 minimum=10,
@@ -316,24 +193,14 @@ def build_app() -> gr.Blocks:
                 step=10,
                 value=100,
             )
+            logs_btn = gr.Button("Get logs")
+            logs_box = gr.Textbox(label="Logs", lines=25)
 
-            with gr.Row():
-                get_logs_btn = gr.Button("Get logs once")
-                follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
-
-            logs_box = gr.HTML(label="Logs", elem_id="logs_terminal")
-
-            get_logs_btn.click(
-                fn=get_pod_logs_once,
+            logs_btn.click(
+                fn=get_pod_logs_handler,
                 inputs=[pod_name, tail_lines],
                 outputs=[logs_box],
             )
-            
-            follow_logs_btn.click(
-                fn=follow_pod_logs,
-                inputs=[pod_name, tail_lines],
-                outputs=logs_box,
-            )
 
     return demo
 
@@ -341,5 +208,4 @@ def build_app() -> gr.Blocks:
 app = build_app()
 
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", "7860"))
-    app.launch(server_name="0.0.0.0", server_port=port)
+    app.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/.gitignore

@@ -0,0 +1,97 @@
+# --- Python ---
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pkl
+*.pyd
+*.so
+
+# Virtual environment
+.venv/
+env/
+venv/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# --- OS files ---
+.DS_Store
+Thumbs.db
+
+# --- VSCode / JetBrains ---
+.vscode/
+.idea/
+
+# --- Logs ---
+*.log
+logs/
+*.out
+*.err
+
+# --- Build / Packaging ---
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# --- Cache ---
+.cache/
+*.cache
+*.mypy_cache/
+*.pytest_cache/
+*.ruff_cache/
+
+# --- Hugging Face / HF Spaces ---
+hf_cache/
+huggingface/
+.environment/
+
+# --- Temp artifacts ---
+tmp/
+temp/
+*.tmp
+
+# --- Credentials / secrets (DO NOT COMMIT) ---
+.env
+.env.local
+.env.*        # safe because no secrets go into repo
+secrets.yml
+*.json.secret
+*.key
+*.pem
+
+# --- Kubernetes ---
+# kubeconfigs or kube generated files
+kubeconfig
+.kube/
+*.yaml.bak
+*~    # backups
+
+# --- Models / Checkpoints ---
+*.pt
+*.bin
+*.onnx
+models/
+checkpoints/
+
+# --- Node (if future UI additions) ---
+node_modules/
+npm-debug.log*
+
+# --- Gradio ---
+gradio_cached_examples/
+
+# --- Ngrok (just in case) ---
+ngrok.yml
+.ngrok/
+
+# --- Minikube artifacts ---
+minikube/
+.kubectl-proxy/
+
+
+# Block OpenAI keys if accidentally named
+openai_key.txt
+openai_api_key.txt

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/README.md

@@ -0,0 +1,16 @@
+---
+title: AgentCTL
+emoji: ⚙️
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+---
+
+
+AgentCTL is a next-generation, agentic control plane for Kubernetes.
+It allows you to create, manage, and observe Kubernetes resources using natural language, backed by a minimal REST client and optional LLM-powered YAML generation.
+
+AgentCTL runs locally or can be deployed to Hugging Face Spaces, allowing cloud-hosted UI + locally hosted Kubernetes clusters.

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/__init__.py

@@ -0,0 +1 @@
+__all__ = ["config", "k8s_client", "agent", "schemas"]

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/agent.py

@@ -0,0 +1,297 @@
+"""Natural language → Kubernetes YAML generator (Job / Deployment / CronJob).
+
+Heuristic templates + optional LLM (OpenAI) for richer YAML.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Tuple
+import os
+import re
+
+# Optional LLM support (OpenAI)
+try:
+    from openai import OpenAI  # pip install openai
+except Exception:  # pragma: no cover
+    OpenAI = None  # type: ignore
+
+
+@dataclass
+class JobSpecRequest:
+    prompt: str
+    name: str = "agentctl-job"
+    image: str = "busybox:1.36"
+    command: Optional[str] = "echo Hello && sleep 5"
+    cpu: str = "500m"
+    memory: str = "512Mi"
+    namespace: str = "default"
+
+
+class K8sAgent:
+    """Agent that turns NL into Job / Deployment / CronJob YAML."""
+
+    # --------------------- Kind detection --------------------- #
+
+    def infer_kind(self, text: str) -> str:
+        t = text.lower()
+
+        # CronJob-ish language
+        if any(w in t for w in ["every minute", "every 5 minutes", "every hour", "cron", "schedule", "scheduled job"]):
+            return "CronJob"
+
+        # Deployment-ish language
+        if any(w in t for w in ["deployment", "service", "web", "api", "server", "nginx", "frontend", "backend"]):
+            return "Deployment"
+
+        # Default to Job
+        return "Job"
+
+    # --------------------- Job templates --------------------- #
+
+    def nl_to_job_request(self, text: str, namespace: str = "default") -> JobSpecRequest:
+        t = text.lower()
+        name = "agentctl-job"
+
+        if "preprocess" in t:
+            name = "preprocess-job"
+        elif "inference" in t:
+            name = "inference-job"
+        elif "train" in t or "training" in t:
+            name = "training-job"
+
+        image = "busybox:1.36"
+        if "python" in t:
+            image = "python:3.11-slim"
+        if "pytorch" in t:
+            image = "pytorch/pytorch:2.3.0-cuda12.1-cudnn9-runtime"
+
+        command = "echo Hello && sleep 5"
+        if "run python" in t:
+            idx = t.find("run python")
+            if idx != -1:
+                # everything from "python" onwards becomes the command
+                fragment = text[idx:].replace("run ", "").strip()
+                command = fragment
+
+        cpu = "500m"
+        memory = "512Mi"
+        if "gpu" in t:
+            cpu = "2000m"
+            memory = "8Gi"
+
+        return JobSpecRequest(
+            prompt=text,
+            name=name,
+            image=image,
+            command=command,
+            cpu=cpu,
+            memory=memory,
+            namespace=namespace,
+        )
+
+    def job_request_to_yaml(self, req: JobSpecRequest) -> str:
+        cmd = ["/bin/sh", "-c", req.command] if req.command else None
+
+        lines = [
+            "apiVersion: batch/v1",
+            "kind: Job",
+            "metadata:",
+            f"  name: {req.name}",
+            f"  namespace: {req.namespace}",
+            "spec:",
+            "  template:",
+            "    metadata:",
+            "      labels:",
+            "        app: agentctl",
+            "    spec:",
+            "      restartPolicy: Never",
+            "      containers:",
+            "        - name: main",
+            f"          image: {req.image}",
+        ]
+        if cmd:
+            lines.append("          command:")
+            for c in cmd:
+                lines.append(f"            - {c}")
+        lines.extend(
+            [
+                "          resources:",
+                "            requests:",
+                f"              cpu: {req.cpu}",
+                f"              memory: {req.memory}",
+                "            limits:",
+                f"              cpu: {req.cpu}",
+                f"              memory: {req.memory}",
+            ]
+        )
+        return "\n".join(lines) + "\n"
+
+    # --------------------- Deployment template --------------------- #
+
+    def nl_to_deployment_yaml(self, text: str, namespace: str = "default") -> str:
+        t = text.lower()
+        name = "agentctl-deployment"
+        image = "nginx:1.27-alpine"
+        replicas = 1
+
+        if "nginx" in t:
+            name = "nginx-deployment"
+        if "python" in t:
+            image = "python:3.11-slim"
+        if "pytorch" in t:
+            image = "pytorch/pytorch:2.3.0-cuda12.1-cudnn9-runtime"
+
+        m = re.search(r"(\d+)\s+replica", t)
+        if m:
+            replicas = int(m.group(1))
+
+        lines = [
+            "apiVersion: apps/v1",
+            "kind: Deployment",
+            "metadata:",
+            f"  name: {name}",
+            f"  namespace: {namespace}",
+            "  labels:",
+            "    app: agentctl-deployment",
+            "spec:",
+            f"  replicas: {replicas}",
+            "  selector:",
+            "    matchLabels:",
+            "      app: agentctl-deployment",
+            "  template:",
+            "    metadata:",
+            "      labels:",
+            "        app: agentctl-deployment",
+            "    spec:",
+            "      containers:",
+            "        - name: main",
+            f"          image: {image}",
+            "          ports:",
+            "            - containerPort: 80",
+        ]
+        return "\n".join(lines) + "\n"
+
+    # --------------------- CronJob template --------------------- #
+
+    def nl_to_cronjob_yaml(self, text: str, namespace: str = "default") -> str:
+        t = text.lower()
+        name = "agentctl-cronjob"
+        image = "busybox:1.36"
+        command = "echo Hello from CronJob && date"
+        schedule = "*/5 * * * *"  # default every 5 minutes
+
+        if "every minute" in t:
+            schedule = "* * * * *"
+        elif "every 5 minutes" in t:
+            schedule = "*/5 * * * *"
+        elif "every hour" in t:
+            schedule = "0 * * * *"
+        elif "every day" in t:
+            schedule = "0 0 * * *"
+
+        if "python" in t:
+            image = "python:3.11-slim"
+        if "run python" in t:
+            idx = t.find("run python")
+            fragment = text[idx:].replace("run ", "").strip()
+            command = fragment
+
+        lines = [
+            "apiVersion: batch/v1",
+            "kind: CronJob",
+            "metadata:",
+            f"  name: {name}",
+            f"  namespace: {namespace}",
+            "spec:",
+            f"  schedule: \"{schedule}\"",
+            "  jobTemplate:",
+            "    spec:",
+            "      template:",
+            "        metadata:",
+            "          labels:",
+            "            app: agentctl-cronjob",
+            "        spec:",
+            "          restartPolicy: Never",
+            "          containers:",
+            "            - name: main",
+            f"              image: {image}",
+            "              command:",
+            "                - /bin/sh",
+            "                - -c",
+            f"                - {command}",
+        ]
+        return "\n".join(lines) + "\n"
+
+    # --------------------- Optional OpenAI LLM --------------------- #
+
+    def maybe_llm_yaml(self, text: str, kind: str, namespace: str, fallback_yaml: str) -> str:
+        """If AGENTCTL_USE_LLM=true and OpenAI is configured, ask the LLM
+        to generate/clean YAML. Otherwise return fallback_yaml.
+        """
+        use_llm = os.getenv("AGENTCTL_USE_LLM", "false").lower() == "true"
+        api_key = os.getenv("OPENAI_API_KEY")
+
+        if not use_llm or not api_key or OpenAI is None:
+            return fallback_yaml
+
+        client = OpenAI(api_key=api_key)
+        model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+
+        system_msg = (
+            "You are an expert Kubernetes engineer. "
+            "Given a natural language request, output a single valid Kubernetes "
+            f"{kind} manifest in YAML. Do not include explanations or code fences."
+        )
+
+        user_msg = (
+            f"Namespace: {namespace}\n"
+            f"Kind: {kind}\n"
+            f"Request: {text}\n\n"
+            "Start from this template and improve it if needed:\n"
+            f"{fallback_yaml}"
+        )
+
+        resp = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_msg},
+                {"role": "user", "content": user_msg},
+            ],
+            temperature=0.1,
+        )
+        content = resp.choices[0].message.content or fallback_yaml
+
+        # Strip ```yaml fences if present
+        content = content.strip()
+        if content.startswith("```"):
+            content = re.sub(r"^```[a-zA-Z]*", "", content).strip()
+            if content.endswith("```"):
+                content = content[:-3].strip()
+
+        return content
+
+    # --------------------- Public entrypoint --------------------- #
+
+    def nl_to_resource_yaml(
+        self,
+        text: str,
+        namespace: str = "default",
+        kind: Optional[str] = None,
+    ) -> Tuple[str, str]:
+        """Return (kind, yaml) for a given prompt."""
+        if not kind or kind.lower() == "auto":
+            kind = self.infer_kind(text)
+
+        if kind == "Job":
+            req = self.nl_to_job_request(text, namespace)
+            base_yaml = self.job_request_to_yaml(req)
+        elif kind == "Deployment":
+            base_yaml = self.nl_to_deployment_yaml(text, namespace)
+        elif kind == "CronJob":
+            base_yaml = self.nl_to_cronjob_yaml(text, namespace)
+        else:
+            raise ValueError(f"Unsupported kind: {kind}")
+
+        final_yaml = self.maybe_llm_yaml(text, kind=kind, namespace=namespace, fallback_yaml=base_yaml)
+        return kind, final_yaml

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/config.py

@@ -0,0 +1,11 @@
+import os
+from dataclasses import dataclass
+
+@dataclass
+class Settings:
+    k8s_api_base_url: str = os.getenv("K8S_API_BASE_URL", "")
+    k8s_namespace: str = os.getenv("K8S_NAMESPACE", "default")
+    verify_ssl: bool = os.getenv("K8S_VERIFY_SSL", "false").lower() == "true"
+    k8s_bearer_token: str | None = os.getenv("K8S_BEARER_TOKEN") or None
+
+settings = Settings()

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/k8s_client.py

@@ -0,0 +1,209 @@
+"""Minimal Kubernetes HTTP client using the public API exposed via ngrok."""
+
+from __future__ import annotations
+
+import json
+from typing import Dict, Any, List
+
+import requests
+import yaml
+
+from .config import settings
+from .schemas import (
+    ApplyResult,
+    JobStatus,
+    PodInfo,
+    ClusterSnapshot,
+    DeploymentStatus,
+    CronJobStatus,
+)
+
+
+class K8sClient:
+    def __init__(self, base_url: str | None = None, namespace: str | None = None):
+        if not base_url:
+            base_url = settings.k8s_api_base_url
+        if not base_url:
+            raise ValueError("K8S_API_BASE_URL is not set. Configure it in env.")
+
+        self.base_url = base_url.rstrip("/")
+        self.namespace = namespace or settings.k8s_namespace
+        self.verify_ssl = settings.verify_ssl
+        self.bearer_token = settings.k8s_bearer_token
+
+    # ------------------------------------------------------------------ #
+    # Internal helpers                                                   #
+    # ------------------------------------------------------------------ #
+
+    def _headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.bearer_token:
+            headers["Authorization"] = f"Bearer {self.bearer_token}"
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        json_body: Dict[str, Any] | None = None,
+    ) -> requests.Response:
+        url = f"{self.base_url}{path}"
+        resp = requests.request(
+            method=method,
+            url=url,
+            headers=self._headers(),
+            json=json_body,
+            verify=self.verify_ssl,
+            timeout=30,
+        )
+        return resp
+
+    # ------------------------------------------------------------------ #
+    # Apply a manifest (Job / Deployment / CronJob)                      #
+    # ------------------------------------------------------------------ #
+
+    def apply_manifest(self, manifest_yaml: str) -> ApplyResult:
+        """Create a resource (Job / Deployment / CronJob) from YAML."""
+        try:
+            manifest = yaml.safe_load(manifest_yaml)
+        except yaml.YAMLError as e:
+            return ApplyResult(success=False, message=f"Invalid YAML: {e}")
+
+        if not isinstance(manifest, dict):
+            return ApplyResult(success=False, message="Manifest must be a single YAML object.")
+
+        kind = manifest.get("kind")
+        metadata = manifest.get("metadata", {})
+        name = metadata.get("name", "<unnamed>")
+        namespace = metadata.get("namespace", self.namespace)
+
+        if kind == "Job":
+            path = f"/apis/batch/v1/namespaces/{namespace}/jobs"
+        elif kind == "Deployment":
+            path = f"/apis/apps/v1/namespaces/{namespace}/deployments"
+        elif kind == "CronJob":
+            path = f"/apis/batch/v1/namespaces/{namespace}/cronjobs"
+        else:
+            return ApplyResult(success=False, message=f"Unsupported kind: {kind}")
+
+        resp = self._request("POST", path, json_body=manifest)
+
+        try:
+            raw = resp.json()
+        except json.JSONDecodeError:
+            raw = {"raw_text": resp.text}
+
+        if resp.status_code in (200, 201):
+            return ApplyResult(
+                success=True,
+                message=f"Created {kind} '{name}' in ns '{namespace}'.",
+                raw_response=raw,
+            )
+
+        return ApplyResult(
+            success=False,
+            message=f"K8s API error {resp.status_code}: {raw}",
+            raw_response=raw,
+        )
+
+    # ------------------------------------------------------------------ #
+    # List helpers for dashboard                                         #
+    # ------------------------------------------------------------------ #
+
+    def list_jobs(self) -> List[JobStatus]:
+        path = f"/apis/batch/v1/namespaces/{self.namespace}/jobs"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        jobs: List[JobStatus] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            status = item.get("status", {})
+            jobs.append(
+                JobStatus(
+                    name=meta.get("name", "<unknown>"),
+                    namespace=meta.get("namespace", self.namespace),
+                    succeeded=status.get("succeeded", 0) or 0,
+                    failed=status.get("failed", 0) or 0,
+                    active=status.get("active", 0) or 0,
+                )
+            )
+        return jobs
+
+    def list_pods(self) -> List[PodInfo]:
+        path = f"/api/v1/namespaces/{self.namespace}/pods"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        pods: List[PodInfo] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            status = item.get("status", {})
+            pods.append(
+                PodInfo(
+                    name=meta.get("name", "<unknown>"),
+                    phase=status.get("phase", "Unknown"),
+                    node_name=status.get("nodeName"),
+                )
+            )
+        return pods
+
+    def list_deployments(self) -> List[DeploymentStatus]:
+        path = f"/apis/apps/v1/namespaces/{self.namespace}/deployments"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        out: List[DeploymentStatus] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            st = item.get("status", {})
+            out.append(
+                DeploymentStatus(
+                    name=meta.get("name", "<unknown>"),
+                    namespace=meta.get("namespace", self.namespace),
+                    replicas=st.get("replicas", 0) or 0,
+                    ready=st.get("readyReplicas", 0) or 0,
+                )
+            )
+        return out
+
+    def list_cronjobs(self) -> List[CronJobStatus]:
+        path = f"/apis/batch/v1/namespaces/{self.namespace}/cronjobs"
+        resp = self._request("GET", path)
+        data = resp.json()
+        items = data.get("items", [])
+        out: List[CronJobStatus] = []
+        for item in items:
+            meta = item.get("metadata", {})
+            st = item.get("status", {})
+            last = st.get("lastScheduleTime")
+            out.append(
+                CronJobStatus(
+                    name=meta.get("name", "<unknown>"),
+                    namespace=meta.get("namespace", self.namespace),
+                    active=len(st.get("active", []) or []),
+                    last_schedule=str(last) if last is not None else None,
+                )
+            )
+        return out
+
+    def get_pod_logs(self, pod_name: str, container: str | None = None, tail_lines: int = 100) -> str:
+        params = {"tailLines": str(tail_lines)}
+        if container:
+            params["container"] = container
+
+        path = f"/api/v1/namespaces/{self.namespace}/pods/{pod_name}/log"
+        url = f"{self.base_url}{path}"
+        resp = requests.get(url, headers=self._headers(), params=params, verify=self.verify_ssl, timeout=30)
+        if resp.status_code == 200:
+            return resp.text
+        return f"Error {resp.status_code}: {resp.text}"
+
+    def snapshot(self) -> ClusterSnapshot:
+        return ClusterSnapshot(
+            namespace=self.namespace,
+            jobs=self.list_jobs(),
+            pods=self.list_pods(),
+            deployments=self.list_deployments(),
+            cronjobs=self.list_cronjobs(),
+        )

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/agentctl/schemas.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+
+
+class ApplyResult(BaseModel):
+    success: bool
+    message: str
+    raw_response: Optional[Dict[str, Any]] = None
+
+
+class JobStatus(BaseModel):
+    name: str
+    namespace: str
+    succeeded: int = 0
+    failed: int = 0
+    active: int = 0
+
+
+class PodInfo(BaseModel):
+    name: str
+    phase: str
+    node_name: Optional[str] = None
+
+
+class DeploymentStatus(BaseModel):
+    name: str
+    namespace: str
+    replicas: int = 0
+    ready: int = 0
+
+
+class CronJobStatus(BaseModel):
+    name: str
+    namespace: str
+    active: int = 0
+    last_schedule: Optional[str] = None
+
+
+class ClusterSnapshot(BaseModel):
+    namespace: str
+    jobs: List[JobStatus] = Field(default_factory=list)
+    pods: List[PodInfo] = Field(default_factory=list)
+    deployments: List[DeploymentStatus] = Field(default_factory=list)
+    cronjobs: List[CronJobStatus] = Field(default_factory=list)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/app.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import time
+from typing import Tuple
+
+import gradio as gr
+
+from agentctl.config import settings
+from agentctl.k8s_client import K8sClient
+from agentctl.agent import K8sAgent
+
+
+# ---------------------------------------------------------------------
+# Core objects
+# ---------------------------------------------------------------------
+
+agent = K8sAgent()
+
+
+def _get_client() -> K8sClient:
+    """Create a Kubernetes HTTP client using env-based config."""
+    return K8sClient()
+
+
+# ---------------------------------------------------------------------
+# YAML generation + apply
+# ---------------------------------------------------------------------
+
+
+def generate_yaml_from_prompt(prompt: str, namespace: str, kind: str) -> str:
+    """Convert natural language + kind selection into YAML."""
+    if not prompt.strip():
+        return "# Enter a description, e.g. 'run a python preprocessing job'"
+
+    ns = namespace.strip() or settings.k8s_namespace
+    kind_sel = None if kind == "Auto" else kind
+
+    _, yaml_text = agent.nl_to_resource_yaml(
+        prompt,
+        namespace=ns,
+        kind=kind_sel,
+    )
+    return yaml_text
+
+
+def apply_yaml_to_cluster(yaml_text: str) -> Tuple[str, str]:
+    """Apply a YAML manifest to the cluster via K8s API."""
+    if not yaml_text.strip():
+        return "No YAML to apply.", ""
+
+    client = _get_client()
+    result = client.apply_manifest(yaml_text)
+
+    raw_str = ""
+    if result.raw_response is not None:
+        try:
+            raw_str = str(result.raw_response)
+        except Exception:
+            raw_str = "<unserialisable response>"
+
+    prefix = "✅" if result.success else "❌"
+    return f"{prefix} {result.message}", raw_str
+
+
+# ---------------------------------------------------------------------
+# Dashboard snapshot
+# ---------------------------------------------------------------------
+
+
+def get_cluster_snapshot() -> str:
+    """Return a human-readable snapshot of Jobs, Pods, Deployments, CronJobs."""
+    client = _get_client()
+    snap = client.snapshot()
+
+    lines: list[str] = [f"Namespace: {snap.namespace}", ""]
+
+    # Jobs
+    lines.append("Jobs:")
+    if not snap.jobs:
+        lines.append("  (no jobs)")
+    else:
+        for j in snap.jobs:
+            lines.append(
+                f"  - {j.name}: succeeded={j.succeeded}, "
+                f"failed={j.failed}, active={j.active}"
+            )
+
+    # Pods
+    lines.append("")
+    lines.append("Pods:")
+    if not snap.pods:
+        lines.append("  (no pods)")
+    else:
+        for p in snap.pods:
+            lines.append(f"  - {p.name}: phase={p.phase}")
+
+    # Deployments
+    lines.append("")
+    lines.append("Deployments:")
+    if not snap.deployments:
+        lines.append("  (no deployments)")
+    else:
+        for d in snap.deployments:
+            lines.append(
+                f"  - {d.name}: replicas={d.replicas}, ready={d.ready}"
+            )
+
+    # CronJobs
+    lines.append("")
+    lines.append("CronJobs:")
+    if not snap.cronjobs:
+        lines.append("  (no cronjobs)")
+    else:
+        for c in snap.cronjobs:
+            last = c.last_schedule or "never"
+            lines.append(
+                f"  - {c.name}: active={c.active}, lastScheduleTime={last}"
+            )
+
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------
+# Logs helpers (colorised terminal + live follow)
+# ---------------------------------------------------------------------
+
+
+def _fetch_pod_logs_raw(pod_name: str, tail_lines: int) -> str:
+    """Internal: raw log text from Kubernetes."""
+    client = _get_client()
+    return client.get_pod_logs(pod_name.strip(), tail_lines=tail_lines)
+
+
+def _colorize_logs(text: str) -> str:
+    """Convert log text into HTML with basic severity colouring."""
+    if not text:
+        return "<span style='color:#888;'>No logs</span>"
+
+    lines = text.splitlines()
+    out: list[str] = []
+
+    for line in lines:
+        if re.search(r"(error|failed|exception)", line, re.IGNORECASE):
+            colour = "#ff4b4b"  # red
+        elif re.search(r"(warn)", line, re.IGNORECASE):
+            colour = "#f7c843"  # yellow
+        elif re.search(r"(info|started|running|completed)", line, re.IGNORECASE):
+            colour = "#5ad55a"  # green
+        else:
+            colour = "#d0d0d0"  # grey
+
+        safe = line.replace("<", "&lt;").replace(">", "&gt;")
+        out.append(f"<span style='color:{colour};'>{safe}</span>")
+
+    return "<br>".join(out)
+
+
+def get_pod_logs_once(pod_name: str, tail_lines: int) -> str:
+    """One-shot logs fetch, used for the 'Get logs' button."""
+    pod_name = pod_name.strip()
+    if not pod_name:
+        return "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
+
+    raw = _fetch_pod_logs_raw(pod_name, tail_lines)
+    return _colorize_logs(raw)
+
+
+def follow_pod_logs(pod_name: str, tail_lines: int):
+    """Live streaming logs using Gradio generator output."""
+    pod_name = pod_name.strip()
+    if not pod_name:
+        yield "<span style='color:#ff4b4b;'>Enter a pod name from the dashboard.</span>"
+        return
+
+    while True:
+        raw = _fetch_pod_logs_raw(pod_name, tail_lines)
+        html = _colorize_logs(raw)
+        yield html
+        time.sleep(2)
+
+
+# CSS for the logs "terminal"
+TERMINAL_CSS = """
+#logs_terminal {
+    background-color: #111111 !important;
+    color: #d0d0d0 !important;
+    font-family: monospace !important;
+    padding: 14px;
+    border-radius: 8px;
+    border: 1px solid #444444;
+    height: 420px;
+    overflow-y: scroll;
+    white-space: pre-wrap;
+}
+"""
+
+
+# ---------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------
+
+
+def build_app() -> gr.Blocks:
+    with gr.Blocks(
+        title="AgentCTL: LLM-Driven Kubernetes Automation",
+        css=TERMINAL_CSS,
+    ) as demo:
+        # Top environment hint (like your screenshot)
+        gr.Markdown(
+            """
+### 🔧 Environment configuration
+
+- `K8S_API_BASE_URL` → **public K8s API URL** (ngrok / Cloudflare tunnel over `kubectl proxy`)
+- `K8S_NAMESPACE` → **default namespace** (e.g. `default`)
+- `K8S_VERIFY_SSL` → **true/false** (set `false` for self-signed ngrok endpoints)
+- `AGENTCTL_USE_LLM` → **true/false** (optional; uses OpenAI if enabled in `agent.py`)
+- `OPENAI_API_KEY` → your key (if LLM mode enabled)
+
+---
+"""
+        )
+
+        # ============================================================
+        # Create Resource tab
+        # ============================================================
+        with gr.Tab("Create Resource"):
+            with gr.Row():
+                prompt = gr.Textbox(
+                    label="Describe the resource you want",
+                    placeholder=(
+                        "Examples:\n"
+                        "- run a python job to preprocess data\n"
+                        "- create an nginx deployment with 3 replicas\n"
+                        "- schedule a python cleanup job every 5 minutes\n"
+                    ),
+                    lines=5,
+                )
+
+                with gr.Column():
+                    namespace = gr.Textbox(
+                        label="Kubernetes namespace",
+                        value=settings.k8s_namespace,
+                        lines=1,
+                    )
+                    kind = gr.Dropdown(
+                        label="Resource kind",
+                        choices=["Auto", "Job", "Deployment", "CronJob"],
+                        value="Auto",
+                    )
+                    gr.Markdown(
+                        "Tip: leave **Auto** to let the agent infer Job vs Deployment vs CronJob."
+                    )
+
+            generate_btn = gr.Button("Generate YAML", variant="primary")
+            yaml_box = gr.Code(
+                label="Generated manifest (YAML)",
+                language="yaml",
+                lines=22,
+            )
+
+            apply_btn = gr.Button("Apply to cluster")
+            apply_msg = gr.Textbox(label="Status", interactive=False)
+            apply_raw = gr.Textbox(label="Raw API response (debug)")
+
+            generate_btn.click(
+                fn=generate_yaml_from_prompt,
+                inputs=[prompt, namespace, kind],
+                outputs=yaml_box,
+            )
+
+            apply_btn.click(
+                fn=apply_yaml_to_cluster,
+                inputs=[yaml_box],
+                outputs=[apply_msg, apply_raw],
+            )
+
+        # ============================================================
+        # Cluster Dashboard tab
+        # ============================================================
+        with gr.Tab("Cluster Dashboard"):
+            gr.Markdown(
+                "Snapshot of **Jobs, Pods, Deployments, CronJobs** in the target namespace."
+            )
+            snapshot_btn = gr.Button("Refresh snapshot", variant="primary")
+            snapshot_box = gr.Textbox(
+                label="Cluster overview",
+                lines=25,
+                interactive=False,
+            )
+
+            snapshot_btn.click(
+                fn=get_cluster_snapshot,
+                inputs=[],
+                outputs=[snapshot_box],
+            )
+
+        # ============================================================
+        # Pod Logs tab
+        # ============================================================
+        with gr.Tab("Pod Logs"):
+            gr.Markdown(
+                "Paste a pod name from the **Cluster Dashboard** (e.g. `agentctl-job-lnrcp`) "
+                "and fetch its logs. Use **Follow logs** for a live `kubectl logs -f` style view."
+            )
+
+            pod_name = gr.Textbox(
+                label="Pod name",
+                placeholder="e.g. preprocess-job-z48rz",
+            )
+            tail_lines = gr.Slider(
+                label="Tail lines",
+                minimum=10,
+                maximum=500,
+                step=10,
+                value=100,
+            )
+
+            with gr.Row():
+                get_logs_btn = gr.Button("Get logs once")
+                follow_logs_btn = gr.Button("Follow logs (live)", variant="primary")
+
+            logs_box = gr.HTML(label="Logs", elem_id="logs_terminal")
+
+            get_logs_btn.click(
+                fn=get_pod_logs_once,
+                inputs=[pod_name, tail_lines],
+                outputs=[logs_box],
+            )
+            
+            follow_logs_btn.click(
+                fn=follow_pod_logs,
+                inputs=[pod_name, tail_lines],
+                outputs=logs_box,
+            )
+
+    return demo
+
+
+app = build_app()
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", "7860"))
+    app.launch(server_name="0.0.0.0", server_port=port)

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+requests>=2.31.0
+PyYAML>=6.0
+pydantic>=2.7.0
+python-dotenv>=1.0.0
+openai>=1.0.0   # for LLM-based YAML generation

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/k8s/deployment-example.yaml

@@ -0,0 +1,22 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: example-nginx-deployment
+  namespace: default
+  labels:
+    app: agentctl-nginx
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: agentctl-nginx
+  template:
+    metadata:
+      labels:
+        app: agentctl-nginx
+    spec:
+      containers:
+        - name: nginx
+          image: nginx:1.27-alpine
+          ports:
+            - containerPort: 80

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/k8s/job-example.yaml

@@ -0,0 +1,21 @@
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: example-echo-job
+  namespace: default
+spec:
+  template:
+    metadata:
+      labels:
+        app: agentctl-example
+    spec:
+      restartPolicy: Never
+      containers:
+        - name: main
+          image: busybox:1.36
+          command:
+            - /bin/sh
+            - -c
+            - |
+              echo "Hello from example job";
+              sleep 10;

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/requirements.txt

@@ -1,6 +1,7 @@
-gradio>=4.0.0
-requests>=2.31.0
-PyYAML>=6.0
-pydantic>=2.7.0
-python-dotenv>=1.0.0
-openai>=1.0.0   # for LLM-based YAML generation
+gradio==4.26.0
+huggingface_hub==0.19.4
+requests==2.31.0
+PyYAML==6.0
+pydantic==2.7.0
+python-dotenv==1.0.0
+openai==1.0.0

hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/hf-space/requirements.txt

@@ -5,3 +5,5 @@ PyYAML==6.0
 pydantic==2.7.0
 python-dotenv==1.0.0
 openai==1.0.0
+fastapi
+uvicorn

hf-space/hf-space/requirements.txt

@@ -7,3 +7,6 @@ python-dotenv==1.0.0
 openai==1.0.0
 fastapi
 uvicorn
+
+# For free LLMs via HuggingFace Inference API
+huggingface_hub==0.19.4