Update app.py

app.py

@@ -1,28 +1,24 @@
 # app.py
 import os
 import threading
-import tempfile
-import json
 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
-from reportlab.lib.pagesizes import letter
-from reportlab.pdfgen import canvas
 
 # -----------------------
 # CONFIG
 # -----------------------
-REPORT_DIR = Path("./reports")
-REPORT_DIR.mkdir(exist_ok=True)
-
 FILE_STORAGE = Path("file_storage")
 FILE_STORAGE.mkdir(exist_ok=True)
+REPORT_DIR = Path("reports")
+REPORT_DIR.mkdir(exist_ok=True)
 
-# MCP ports
 FILE_SERVER_PORT = 8001
 EXECUTOR_PORT = 8002
 MEMORY_PORT = 8003
@@ -30,10 +26,11 @@ MEMORY_PORT = 8003
 # -----------------------
 # MCP SERVERS
 # -----------------------
-
-# --- File Server ---
 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
@@ -42,7 +39,7 @@ async def upload_file(file: UploadFile = File(...)):
         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,"path":str(dest)}
+    return {"status": "ok", "filename": file.filename}
 
 @file_app.get("/list")
 def list_files():
@@ -52,11 +49,10 @@ def list_files():
 def read_file(name: str):
     fpath = FILE_STORAGE / name
     if not fpath.exists():
-        return {"error":"not found"}
+        return {"error": "not found"}
     return {"filename": name, "content": fpath.read_text(encoding="utf-8")}
 
 # --- Executor Server ---
-executor_app = FastAPI()
 EXECUTOR_DB = Path("executor_db")
 EXECUTOR_DB.mkdir(exist_ok=True)
 
@@ -74,10 +70,9 @@ def apply_patch(req: dict):
         existing = json.loads(fname.read_text())
     existing.append(rec)
     fname.write_text(json.dumps(existing, indent=2))
-    return {"status":"applied","record": rec}
+    return {"status": "applied", "record": rec}
 
 # --- Memory Server ---
-memory_app = FastAPI()
 MEMORY_DB = Path("memory_db")
 MEMORY_DB.mkdir(exist_ok=True)
 MEMORY_FILE = MEMORY_DB / "memory.json"
@@ -86,12 +81,12 @@ if not MEMORY_FILE.exists():
 
 @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 = json.loads(MEMORY_FILE.read_text())
     m[key] = value
     MEMORY_FILE.write_text(json.dumps(m, indent=2))
-    return {"status":"ok","key":key}
+    return {"status": "ok", "key": key}
 
 @memory_app.get("/get/{key}")
 def get_memory(key: str):
@@ -101,35 +96,44 @@ def get_memory(key: str):
 # -----------------------
 # HELPER FUNCTIONS
 # -----------------------
-def upload_file_to_mcp(filepath, filename):
-    url = f"http://localhost:{FILE_SERVER_PORT}/upload"
-    with open(filepath, "rb") as f:
-        files = {"file": (filename, f)}
-        r = requests.post(url, files=files, timeout=30)
-        r.raise_for_status()
-        return r.json()
-
 def list_mcp_files():
     try:
-        return requests.get(f"http://localhost:{FILE_SERVER_PORT}/list").json()
+        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):
-    return requests.get(f"http://localhost:{FILE_SERVER_PORT}/read/{name}").json()
+    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 {}}
-    return requests.post(f"http://localhost:{EXECUTOR_PORT}/apply", json=payload).json()
+    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):
-    return requests.post(f"http://localhost:{MEMORY_PORT}/set", json={"key":key,"value":value}).json()
+    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):
-    return requests.get(f"http://localhost:{MEMORY_PORT}/get/{key}").json()
+    try:
+        r = requests.get(f"http://localhost:{MEMORY_PORT}/get/{key}", timeout=5)
+        return r.json()
+    except:
+        return {"error": "memory not reachable"}
 
 # -----------------------
-# LOG ANALYSIS & PLAN
+# LOG ANALYSIS
 # -----------------------
 def parse_log_text(txt):
     lines = txt.splitlines()
@@ -143,7 +147,7 @@ def analyze_and_plan(filename):
         return {"summary": "File not found", "issues": [], "suggestions": [], "plan_text": ""}
     text = r.get("content","")
     parsed = parse_log_text(text)
-    summary = f"Detected {len(parsed['errors'])} errors and {len(parsed['warnings'])} warnings"
+    summary = f"Detected {len(parsed['errors'])} errors and {len(parsed['warnings'])} warnings in {parsed['total_lines']} lines."
     issues = parsed["errors"][:10] + parsed["warnings"][:10]
     suggestions = [
         "Investigate top errors",
@@ -185,17 +189,6 @@ def generate_incident_report(filename, summary, issues, suggestions):
     c.save()
     return str(out)
 
-def apply_fix_action(filename, action_key):
-    mapping = {
-        "increase_timeout": ("update_timeout", {"timeout": 60}),
-        "increase_retries": ("increase_retries", {"retries": 3}),
-        "mark_fixed": ("mark_fixed", {})
-    }
-    action, params = mapping.get(action_key, ("custom_action", {"note": action_key}))
-    res = apply_patch_mcp(filename, action, params)
-    memory_set(f"last_patch_{filename}", json.dumps(res))
-    return res
-
 # -----------------------
 # GRADIO UI
 # -----------------------
@@ -217,52 +210,42 @@ with gr.Blocks() as demo:
             plan_box = gr.Textbox(label="Agent Plan / Reasoning", lines=6)
             report_download = gr.File(label="Last Report (download)")
 
-    # Refresh or initialize file dropdown
-    def refresh_files():
-        try:
-            resp = list_mcp_files()
-            files = resp.get("files", [])
-            if not files:
-                files = [f.name for f in FILE_STORAGE.iterdir() if f.is_file()]
-            return files
-        except Exception as e:
-            print("Error fetching files:", e)
-            return []
+    # Initialize dropdown
+    files_list.choices = [f for f in FILE_STORAGE.iterdir() if f.is_file()]
 
-    files_list.choices = refresh_files()
+    def refresh_files():
+        return list_mcp_files().get("files", [])
 
-    btn_refresh.click(fn=refresh_files, outputs=files_list)
+    btn_refresh.click(fn=refresh_files, outputs=[files_list])
 
     def on_upload(file_obj):
         if file_obj is None:
             return refresh_files()
-        try:
-            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()
-        except Exception as e:
-            print("Upload error:", e)
-            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 "Select file first", "", "", "", None
+            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)
+        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], outputs=[summary_box, issues_box, suggestions_box, plan_box, report_download])
+    btn_analyze.click(fn=analyze_selected, inputs=[files_list],
+                      outputs=[summary_box, issues_box, suggestions_box, plan_box, report_download])
 
     def apply_action(fname, action_key):
         if not fname:
-            return "Select file first"
-        res = apply_fix_action(fname, action_key)
+            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])
@@ -270,16 +253,13 @@ with gr.Blocks() as demo:
 # -----------------------
 # 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")
+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)
+    demo.launch(server_name="0.0.0.0", server_port=7860)