Update app.py

app.py

@@ -1,15 +1,11 @@
 # app.py
 import os
-import threading
 import datetime
 import json
 from pathlib import Path
-import requests
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 import gradio as gr
-from fastapi import FastAPI, UploadFile, File
-import uvicorn
 
 # -----------------------
 # CONFIG
@@ -19,121 +15,8 @@ FILE_STORAGE.mkdir(exist_ok=True)
 REPORT_DIR = Path("reports")
 REPORT_DIR.mkdir(exist_ok=True)
 
-FILE_SERVER_PORT = 8001
-EXECUTOR_PORT = 8002
-MEMORY_PORT = 8003
-
-# -----------------------
-# MCP SERVERS
-# -----------------------
-file_app = FastAPI()
-executor_app = FastAPI()
-memory_app = FastAPI()
-
-# --- File Server ---
-@file_app.post("/upload")
-async def upload_file(file: UploadFile = File(...)):
-    dest = FILE_STORAGE / file.filename
-    content = await file.read()
-    if isinstance(content, bytes):
-        content = content.decode("utf-8", errors="ignore")
-    with open(dest, "w", encoding="utf-8") as f:
-        f.write(content)
-    return {"status": "ok", "filename": file.filename}
-
-@file_app.get("/list")
-def list_files():
-    return {"files": [p.name for p in FILE_STORAGE.iterdir() if p.is_file()]}
-
-@file_app.get("/read/{name}")
-def read_file(name: str):
-    fpath = FILE_STORAGE / name
-    if not fpath.exists():
-        return {"error": "not found"}
-    return {"filename": name, "content": fpath.read_text(encoding="utf-8")}
-
-# --- Executor Server ---
-EXECUTOR_DB = Path("executor_db")
-EXECUTOR_DB.mkdir(exist_ok=True)
-
-@executor_app.post("/apply")
-def apply_patch(req: dict):
-    rec = {
-        "filename": req.get("filename"),
-        "action": req.get("action"),
-        "params": req.get("params", {}),
-        "timestamp": datetime.datetime.utcnow().isoformat()
-    }
-    fname = EXECUTOR_DB / f"{rec['filename']}.patchlog.json"
-    existing = []
-    if fname.exists():
-        existing = json.loads(fname.read_text())
-    existing.append(rec)
-    fname.write_text(json.dumps(existing, indent=2))
-    return {"status": "applied", "record": rec}
-
-# --- Memory Server ---
-MEMORY_DB = Path("memory_db")
-MEMORY_DB.mkdir(exist_ok=True)
-MEMORY_FILE = MEMORY_DB / "memory.json"
-if not MEMORY_FILE.exists():
-    MEMORY_FILE.write_text(json.dumps({}))
-
-@memory_app.post("/set")
-def set_memory(item: dict):
-    m = json.loads(MEMORY_FILE.read_text())
-    key = item.get("key")
-    value = item.get("value")
-    m[key] = value
-    MEMORY_FILE.write_text(json.dumps(m, indent=2))
-    return {"status": "ok", "key": key}
-
-@memory_app.get("/get/{key}")
-def get_memory(key: str):
-    m = json.loads(MEMORY_FILE.read_text())
-    return {"value": m.get(key)}
-
-# -----------------------
-# HELPER FUNCTIONS
-# -----------------------
-def list_mcp_files():
-    try:
-        r = requests.get(f"http://localhost:{FILE_SERVER_PORT}/list", timeout=5)
-        return r.json()
-    except:
-        return {"files": [f.name for f in FILE_STORAGE.iterdir() if f.is_file()]}
-
-def read_mcp_file(name):
-    try:
-        r = requests.get(f"http://localhost:{FILE_SERVER_PORT}/read/{name}", timeout=5)
-        return r.json()
-    except:
-        return {"error": "file read failed"}
-
-def apply_patch_mcp(filename, action, params=None):
-    payload = {"filename": filename, "action": action, "params": params or {}}
-    try:
-        r = requests.post(f"http://localhost:{EXECUTOR_PORT}/apply", json=payload, timeout=5)
-        return r.json()
-    except:
-        return {"error": "executor not reachable"}
-
-def memory_set(key, value):
-    try:
-        r = requests.post(f"http://localhost:{MEMORY_PORT}/set", json={"key": key, "value": value}, timeout=5)
-        return r.json()
-    except:
-        return {"error": "memory not reachable"}
-
-def memory_get(key):
-    try:
-        r = requests.get(f"http://localhost:{MEMORY_PORT}/get/{key}", timeout=5)
-        return r.json()
-    except:
-        return {"error": "memory not reachable"}
-
 # -----------------------
-# LOG ANALYSIS
+# LOG ANALYSIS FUNCTIONS
 # -----------------------
 def parse_log_text(txt):
     lines = txt.splitlines()
@@ -141,125 +24,101 @@ def parse_log_text(txt):
     warnings = [l for l in lines if "WARNING" in l or "WARN" in l]
     return {"errors": errors, "warnings": warnings, "total_lines": len(lines)}
 
-def analyze_and_plan(filename):
-    r = read_mcp_file(filename)
-    if "error" in r:
-        return {"summary": "File not found", "issues": [], "suggestions": [], "plan_text": ""}
-    text = r.get("content","")
+def analyze_log(filename):
+    filepath = FILE_STORAGE / filename
+    if not filepath.exists():
+        return {"summary":"File not found","issues":[],"suggestions":[],"plan":""}
+    
+    text = filepath.read_text(encoding="utf-8", errors="ignore")
     parsed = parse_log_text(text)
+    
     summary = f"Detected {len(parsed['errors'])} errors and {len(parsed['warnings'])} warnings in {parsed['total_lines']} lines."
-    issues = parsed["errors"][:10] + parsed["warnings"][:10]
+    issues = parsed['errors'][:10] + parsed['warnings'][:10]
     suggestions = [
         "Investigate top errors",
         "Check system configuration",
         "Add proper exception handling"
     ]
-    plan_text = "\n".join([
+    plan = "\n".join([
         "STEP 1: Review errors",
         "STEP 2: Apply suggested fixes",
         "STEP 3: Re-run analysis"
     ])
-    return {"summary": summary, "issues": issues, "suggestions": suggestions, "plan_text": plan_text}
+    return {"summary": summary, "issues": issues, "suggestions": suggestions, "plan": plan}
 
-def generate_incident_report(filename, summary, issues, suggestions):
-    now = datetime.datetime.utcnow().isoformat().replace(":", "-")
+def generate_report(filename, summary, issues, suggestions):
+    now = datetime.datetime.utcnow().strftime("%Y%m%d-%H%M%S")
     out = REPORT_DIR / f"incident_{filename}_{now}.pdf"
     c = canvas.Canvas(str(out), pagesize=letter)
-    c.setFont("Helvetica-Bold", 16)
-    c.drawString(40, 750, f"Incident Report - {filename}")
-    c.setFont("Helvetica", 10)
-    c.drawString(40, 730, f"Generated: {datetime.datetime.utcnow().isoformat()}")
-    y = 700
-    c.drawString(40, y, "Summary:")
-    c.drawString(60, y-20, summary[:1000])
-    y -= 60
-    c.drawString(40, y, "Issues:")
+    c.setFont("Helvetica-Bold",16)
+    c.drawString(40,750,f"Incident Report - {filename}")
+    c.setFont("Helvetica",10)
+    c.drawString(40,730,f"Generated: {datetime.datetime.utcnow().isoformat()}")
+    y=700
+    c.drawString(40,y,"Summary:")
+    c.drawString(60,y-20,summary[:1000])
+    y-=60
+    c.drawString(40,y,"Issues:")
     for it in issues:
-        y -= 14
-        c.drawString(60, y, it[:120])
-        if y < 80:
-            c.showPage(); y = 740
-    y -= 20
-    c.drawString(40, y, "Suggestions:")
+        y-=14
+        c.drawString(60,y,it[:120])
+        if y<80:
+            c.showPage()
+            y=740
+    y-=20
+    c.drawString(40,y,"Suggestions:")
     for s in suggestions:
-        y -= 14
-        c.drawString(60, y, f"- {s[:100]}")
-        if y < 80:
-            c.showPage(); y = 740
+        y-=14
+        c.drawString(60,y,f"- {s[:100]}")
+        if y<80:
+            c.showPage()
+            y=740
     c.save()
     return str(out)
 
 # -----------------------
 # GRADIO UI
 # -----------------------
+def refresh_files():
+    return [f.name for f in FILE_STORAGE.iterdir() if f.is_file()]
+
+def upload_file(file_obj):
+    if file_obj is None:
+        return refresh_files()
+    filepath = FILE_STORAGE / file_obj.name
+    content = file_obj.read()
+    if isinstance(content, bytes):
+        content = content.decode("utf-8", errors="ignore")
+    filepath.write_text(content, encoding="utf-8")
+    return refresh_files()
+
+def analyze_selected(filename):
+    if not filename:
+        return "", "", "", "", None
+    out = analyze_log(filename)
+    report_path = generate_report(filename, out["summary"], out["issues"], out["suggestions"])
+    return (out["summary"], "\n".join(out["issues"]), "\n".join(out["suggestions"]), out["plan"], gr.File.update(value=report_path))
+
 with gr.Blocks() as demo:
-    gr.Markdown("## AgentOps MCP - Log Analysis & Agent Planning")
+    gr.Markdown("## AgentOps MCP - Log Analysis")
     with gr.Row():
         with gr.Column(scale=2):
             upload = gr.File(label="Upload log file", file_types=[".txt"])
             btn_upload = gr.Button("Upload File")
-            files_list = gr.Dropdown(choices=[], label="Files on MCP Server", interactive=True)
+            files_dropdown = gr.Dropdown(choices=refresh_files(), label="Files available")
             btn_refresh = gr.Button("Refresh files")
             btn_analyze = gr.Button("Analyze selected file")
-            apply_dropdown = gr.Dropdown(choices=["increase_timeout","increase_retries","mark_fixed"], label="Select fix action")
-            btn_apply = gr.Button("Apply fix")
         with gr.Column(scale=3):
-            summary_box = gr.Textbox(label="Agent Summary", lines=6)
+            summary_box = gr.Textbox(label="Summary", lines=3)
             issues_box = gr.Textbox(label="Detected Issues", lines=10)
-            suggestions_box = gr.Textbox(label="Suggested Fixes", lines=6)
-            plan_box = gr.Textbox(label="Agent Plan / Reasoning", lines=6)
-            report_download = gr.File(label="Last Report (download)")
-
-    # Initialize dropdown
-    files_list.choices = [f for f in FILE_STORAGE.iterdir() if f.is_file()]
-
-    def refresh_files():
-        return list_mcp_files().get("files", [])
-
-    btn_refresh.click(fn=refresh_files, outputs=[files_list])
+            suggestions_box = gr.Textbox(label="Suggestions", lines=6)
+            plan_box = gr.Textbox(label="Agent Plan", lines=6)
+            report_download = gr.File(label="Download PDF Report")
 
-    def on_upload(file_obj):
-        if file_obj is None:
-            return refresh_files()
-        content = file_obj.read()
-        if isinstance(content, bytes):
-            content = content.decode("utf-8", errors="ignore")
-        tmp = FILE_STORAGE / file_obj.name
-        with open(tmp, "w", encoding="utf-8") as f:
-            f.write(content)
-        return refresh_files()
-
-    btn_upload.click(fn=on_upload, inputs=[upload], outputs=[files_list])
-
-    def analyze_selected(fname):
-        if not fname:
-            return "", "", "", "", None
-        out = analyze_and_plan(fname)
-        report_path = generate_incident_report(fname, out["summary"], out["issues"], out["suggestions"])
-        return (out["summary"], "\n".join(out["issues"]), "\n".join(out["suggestions"]),
-                out["plan_text"], gr.File.update(value=report_path))
-
-    btn_analyze.click(fn=analyze_selected, inputs=[files_list],
+    btn_refresh.click(fn=refresh_files, outputs=files_dropdown)
+    btn_upload.click(fn=upload_file, inputs=upload, outputs=files_dropdown)
+    btn_analyze.click(fn=analyze_selected, inputs=files_dropdown,
                       outputs=[summary_box, issues_box, suggestions_box, plan_box, report_download])
 
-    def apply_action(fname, action_key):
-        if not fname:
-            return ""
-        res = apply_patch_mcp(fname, action_key)
-        return json.dumps(res, indent=2)
-
-    btn_apply.click(fn=apply_action, inputs=[files_list, apply_dropdown], outputs=[plan_box])
-
-# -----------------------
-# START MCP SERVERS
-# -----------------------
-def start_file_server(): uvicorn.run(file_app, host="0.0.0.0", port=FILE_SERVER_PORT, log_level="error")
-def start_executor_server(): uvicorn.run(executor_app, host="0.0.0.0", port=EXECUTOR_PORT, log_level="error")
-def start_memory_server(): uvicorn.run(memory_app, host="0.0.0.0", port=MEMORY_PORT, log_level="error")
-
-threading.Thread(target=start_file_server, daemon=True).start()
-threading.Thread(target=start_executor_server, daemon=True).start()
-threading.Thread(target=start_memory_server, daemon=True).start()
-
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)