Update app.py

app.py

@@ -1,411 +1,143 @@
-"""
-GenBuddy — Intelligent App Builder (Hugging Face Gradio Space)
-
-Features:
-- Name & gender customization + memory
-- Detects framework from natural language or explicit pick
-- Generates Full (runnable) or Lightweight project scaffolds for:
-  React, Node/Express, Flask, Django, .NET (C#)
-- Accepts uploaded files to include in project
-- Basic code analysis and diagnostics
-- Packages project as downloadable zip
-- Keeps templates for repeated tasks (auto-apply on repeat)
-"""
-
 import gradio as gr
 import os
-import re
+import time
+import traceback
 import json
-import shutil
-import zipfile
+import re
 import tempfile
 from datetime import datetime
-from pathlib import Path
-
-# -------------- Persistence (simple JSON memory) --------------
-MEMORY_FN = "genbuddy_memory.json"
-if os.path.exists(MEMORY_FN):
-    try:
-        with open(MEMORY_FN, "r", encoding="utf-8") as f:
-            MEMORY = json.load(f)
-    except Exception:
-        MEMORY = {}
-else:
-    MEMORY = {}
-
-def save_memory():
-    with open(MEMORY_FN, "w", encoding="utf-8") as f:
-        json.dump(MEMORY, f, indent=2)
-
-def ensure_user(user_id="default"):
-    if user_id not in MEMORY:
-        MEMORY[user_id] = {
-            "name": "GenBuddy",
-            "gender": "female",
-            "preferences": {"tone": "friendly", "verbosity": "medium"},
-            "templates": {},
-            "history": []
-        }
-        save_memory()
-
-# -------------- Utilities --------------
-def nowtag():
-    return datetime.now().strftime("%Y%m%d%H%M%S")
-
-def zip_folder(src_dir, out_path):
-    with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for root, _, files in os.walk(src_dir):
-            for f in files:
-                full = os.path.join(root, f)
-                arc = os.path.relpath(full, src_dir)
-                zf.write(full, arc)
-    return out_path
-
-def write_file(path, content, mode="w"):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, mode, encoding="utf-8") as f:
-        f.write(content)
-
-def detect_framework_from_text(text):
-    t = text.lower()
-    mapping = {
-        "react": ["react", "create react", "vite react", "next.js", "next js"],
-        "node": ["node", "express", "expressjs"],
-        "flask": ["flask", "python flask"],
-        "django": ["django", "python django"],
-        "dotnet": ["dotnet", ".net", "c#", "csharp", "asp.net"],
-        "react_native": ["react native", "react-native"],
-        "flutter": ["flutter"]
-    }
-    for key, keywords in mapping.items():
-        for k in keywords:
-            if k in t:
-                return key
-    return None
-
-def detect_language_from_filename(filename):
-    ext = Path(filename).suffix.lower()
-    return {
-        ".py": "python",
-        ".js": "javascript",
-        ".ts": "typescript",
-        ".cs": "csharp",
-        ".java": "java",
-        ".html": "html",
-        ".css": "css",
-        ".json": "json"
-    }.get(ext, "unknown")
-
-def analyze_uploaded_file_bytes(name, bts):
-    try:
-        txt = bts.decode("utf-8", errors="ignore")
-    except:
-        return {"name": name, "error": "Could not decode file"}
-    lines = txt.splitlines()
-    stats = {"name": name, "lines": len(lines), "empty": sum(1 for l in lines if not l.strip())}
-    stats["language"] = detect_language_from_filename(name)
-    # simple heuristics:
-    stats["functions"] = sum(1 for l in lines if re.search(r"\bdef\b|\bfunction\b|\bclass\b", l))
-    stats["has_imports"] = bool(re.search(r"\bimport\b|\brequire\b|\busing\b", txt))
-    return stats
-
-# -------------- Project Generators --------------
-def gen_react_full(target_dir, app_name="genbuddy-app"):
-    # package.json
-    package = {
-        "name": app_name,
-        "version": "0.1.0",
-        "private": True,
-        "scripts": {
-            "start": "vite",
-            "build": "vite build",
-            "dev": "vite"
-        },
-        "dependencies": {
-            "react": "^18.2.0",
-            "react-dom": "^18.2.0"
-        },
-        "devDependencies": {
-            "vite": "^5.0.0"
-        }
-    }
-    write_file(os.path.join(target_dir, "package.json"), json.dumps(package, indent=2))
-    write_file(os.path.join(target_dir, "index.html"),
-               "<!doctype html><html><head><meta charset='utf-8'><title>GenBuddy React</title></head><body><div id='root'></div><script type='module' src='/src/main.jsx'></script></body></html>")
-    write_file(os.path.join(target_dir, "src", "main.jsx"),
-               "import React from 'react';\nimport { createRoot } from 'react-dom/client';\nimport App from './App';\ncreateRoot(document.getElementById('root')).render(<App/>);")
-    write_file(os.path.join(target_dir, "src", "App.jsx"),
-               "export default function App(){return (<div style={{fontFamily:'system-ui',padding:24}}> <h1>GenBuddy React App</h1><p>Welcome — scaffold generated by GenBuddy.</p></div>)}")
-    write_file(os.path.join(target_dir, "README.md"),
-               "This is a Vite + React scaffold generated by GenBuddy. Install with `npm install` and run `npm run dev`.")
-
-def gen_react_light(target_dir, app_name="genbuddy-app"):
-    # Single HTML with CDN React (lightweight)
-    html = """<!doctype html>
-<html>
-<head><meta charset="utf-8"><title>GenBuddy React (Light)</title></head>
-<body>
-<div id="root"></div>
-<script crossorigin src="https://unpkg.com/react@18/umd/react.development.js"></script>
-<script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></script>
-<script>
-const e = React.createElement;
-function App(){ return e('div', {style:{fontFamily:'system-ui', padding:20}}, e('h1', null, 'GenBuddy Light React'), e('p', null, 'This is a lightweight scaffold using CDN React.'))}
-ReactDOM.createRoot(document.getElementById('root')).render(e(App));
-</script>
-</body>
-</html>"""
-    write_file(os.path.join(target_dir, "index.html"), html)
-
-def gen_node_express_full(target_dir, app_name="genbuddy-node"):
-    package = {
-        "name": app_name,
-        "version": "0.1.0",
-        "scripts": {"start": "node server.js"},
-        "dependencies": {"express": "^4.18.2"}
-    }
-    write_file(os.path.join(target_dir, "package.json"), json.dumps(package, indent=2))
-    write_file(os.path.join(target_dir, "server.js"),
-               "const express = require('express');\nconst app = express();\napp.use(express.json());\napp.get('/', (req, res)=> res.send('<h1>GenBuddy Node App</h1>'));\napp.listen(3000, ()=> console.log('Server listening on :3000'))")
-    write_file(os.path.join(target_dir, "README.md"), "Install with npm install; run with npm start")
+from io import BytesIO
 
-def gen_node_express_light(target_dir):
-    write_file(os.path.join(target_dir, "server.js"),
-               "const http = require('http');\nhttp.createServer((req,res)=>{res.end('<h1>GenBuddy lightweight Node</h1>')}).listen(3000)")
-    write_file(os.path.join(target_dir, "README.md"), "Light Node HTTP server; run with `node server.js`")
+# ============================================================
+#  GENBUDDY — INTELLIGENT APP BUILDER
+# ============================================================
 
-def gen_flask_full(target_dir):
-    write_file(os.path.join(target_dir, "requirements.txt"), "flask\n")
-    write_file(os.path.join(target_dir, "app.py"),
-               "from flask import Flask, render_template_string\napp = Flask(__name__)\n@app.route('/')\ndef index():\n    return '<h1>GenBuddy Flask App</h1>'\n\nif __name__=='__main__':\n    app.run(host='0.0.0.0', port=5000)")
-    write_file(os.path.join(target_dir, "README.md"), "Install with `pip install -r requirements.txt` and run `python app.py`")
-
-def gen_flask_light(target_dir):
-    gen_flask_full(target_dir)  # Flask is already lightweight; keep same but note minimal
-
-def gen_django_full(target_dir, project_name="genbuddy_site"):
-    # Create minimal manage.py and project settings (not executing django-admin here)
-    write_file(os.path.join(target_dir, "README.md"),
-               "Django scaffold. For full project, run `django-admin startproject {}` locally and merge files.".format(project_name))
-    write_file(os.path.join(target_dir, "notes.txt"),
-               "Django full scaffolding needs django-admin; GenBuddy provides a starter README to guide you.")
-
-def gen_dotnet_full(target_dir):
-    # Provide .csproj and Program.cs minimal for dotnet 6/7
-    write_file(os.path.join(target_dir, "Program.cs"),
-               "using System;\nConsole.WriteLine(\"GenBuddy .NET scaffold — create a proper project using `dotnet new web` locally.\");")
-    write_file(os.path.join(target_dir, "README.md"),
-               "Dotnet scaffold: run `dotnet new web -o .` locally to initialize a runnable project.")
+APP_TITLE = "GenBuddy — Intelligent App Builder"
+APP_DESCRIPTION = """
+An evolving AI developer that automates app creation, debugging, and optimization.  
+Built for intelligent, autonomous workflow completion with minimal user input.
+"""
 
-def gen_generic_web(target_dir, command):
-    # fallback HTML/CSS/JS scaffold
-    write_file(os.path.join(target_dir, "index.html"),
-               f"<!doctype html><html><head><meta charset='utf-8'><title>GenBuddy App</title></head><body><h1>Generated App</h1><p>{command}</p></body></html>")
-    write_file(os.path.join(target_dir, "styles.css"), "body{font-family:system-ui;padding:20px;}")
+# ============================================================
+#  CORE BEHAVIOR LOGIC
+# ============================================================
 
-# -------------- High-level builder --------------
-def build_project_from_spec(spec, mode="light", include_files=None, project_name=None):
+def analyze_code(code_text):
     """
-    spec: dict with keys 'framework' or 'command'
-    mode: 'full' or 'light'
-    include_files: list of dicts: {"name":..., "content_bytes":...}
-    project_name: optional string
-    returns zip_path
+    Analyzes user-submitted code, detects the language, checks for errors,
+    and returns optimization or bug-fix suggestions.
     """
-    tag = nowtag()
-    base = tempfile.mkdtemp(prefix=f"genbuddy_{tag}_")
-    project_name = project_name or f"genbuddy_project_{tag}"
-    target_dir = os.path.join(base, project_name)
-    os.makedirs(target_dir, exist_ok=True)
-
-    # include user uploaded files
-    if include_files:
-        for f in include_files:
-            dest = os.path.join(target_dir, f["name"])
-            os.makedirs(os.path.dirname(dest), exist_ok=True)
-            with open(dest, "wb") as fh:
-                fh.write(f["content_bytes"])
-
-    framework = spec.get("framework")
-    command = spec.get("command", "")
-
-    # Dispatch generators
-    if framework == "react":
-        if mode == "full":
-            gen_react_full(target_dir, app_name=project_name)
-        else:
-            gen_react_light(target_dir, app_name=project_name)
-    elif framework == "node":
-        if mode == "full":
-            gen_node_express_full(target_dir, app_name=project_name)
+    try:
+        # Detect language (simplified pattern matching)
+        if "def " in code_text:
+            lang = "Python"
+        elif "function " in code_text or "const " in code_text:
+            lang = "JavaScript"
+        elif "#include" in code_text:
+            lang = "C/C++"
+        elif "public class" in code_text:
+            lang = "C# / Java"
         else:
-            gen_node_express_light(target_dir)
-    elif framework == "flask":
-        gen_flask_full(target_dir) if mode == "full" else gen_flask_light(target_dir)
-    elif framework == "django":
-        gen_django_full(target_dir, project_name=project_name)
-    elif framework == "dotnet":
-        gen_dotnet_full(target_dir)
-    else:
-        # try to guess from command text
-        guessed = detect_framework_from_text(command)
-        if guessed:
-            return build_project_from_spec({"framework": guessed, "command": command}, mode=mode, include_files=include_files, project_name=project_name)
-        # fallback generic web scaffold
-        gen_generic_web(target_dir, command)
-
-    # write a manifest
-    manifest = {
-        "generated_at": datetime.utcnow().isoformat(),
-        "framework": framework or "generic",
-        "mode": mode,
-        "command": command,
-        "project_name": project_name
-    }
-    write_file(os.path.join(target_dir, "genbuddy_manifest.json"), json.dumps(manifest, indent=2))
+            lang = "Unknown"
 
-    # Zip it
-    out_zip = os.path.join(tempfile.gettempdir(), f"{project_name}.zip")
-    zip_folder(target_dir, out_zip)
+        issues = []
+        if "print(" not in code_text and lang == "Python":
+            issues.append("No output function found (add print or return statements).")
+        if "TODO" in code_text:
+            issues.append("Contains TODO comments — incomplete logic.")
 
-    # Cleanup
-    shutil.rmtree(base, ignore_errors=True)
-    return out_zip
+        summary = f"Language Detected: **{lang}**\n"
+        if issues:
+            summary += "\n⚠️ Issues Found:\n" + "\n".join(f"- {i}" for i in issues)
+        else:
+            summary += "\n✅ No major issues found."
 
-# -------------- Intent / Command Handler --------------
-def handle_user_interaction(user_id, name, gender, mode, explicit_framework, command_text, uploaded):
-    ensure_user(user_id)
-    # set name/gender when provided
-    if name:
-        MEMORY[user_id]["name"] = name
-    if gender:
-        MEMORY[user_id]["gender"] = gender
-    save_memory()
+        return summary
+    except Exception as e:
+        return f"❌ Error analyzing code:\n{traceback.format_exc()}"
 
-    # Save to history
-    MEMORY[user_id].setdefault("history", []).append({"ts": datetime.utcnow().isoformat(), "input": command_text})
-    save_memory()
 
-    # Prepare include files
-    include_files = []
-    if uploaded:
-        # uploaded may be list of file-like objects
-        if isinstance(uploaded, list):
-            for f in uploaded:
-                include_files.append({"name": f.name, "content_bytes": f.read()})
-        else:
-            f = uploaded
-            include_files.append({"name": f.name, "content_bytes": f.read()})
+def improve_code(code_text):
+    """
+    Performs simple auto-improvements (e.g., adds docstrings, fixes minor syntax).
+    """
+    try:
+        improved = code_text.strip()
 
-    # Analyze uploaded files quickly
-    analysis = [analyze_uploaded_file_bytes(f["name"], f["content_bytes"]) for f in include_files]
+        # Auto-add docstring if missing
+        if "def " in improved and '"""' not in improved:
+            improved = re.sub(
+                r"(def\s+\w+\(.*\):)",
+                r'\1\n    """Auto-generated by GenBuddy: function purpose unclear."""',
+                improved,
+            )
 
-    # Decide framework
-    framework = explicit_framework or detect_framework_from_text(command_text)
-    spec = {"framework": framework, "command": command_text}
+        # Remove trailing whitespace and normalize indentation
+        improved = "\n".join(line.rstrip() for line in improved.splitlines())
 
-    # Mode handling
-    mode_key = "full" if mode == "Full (runnable)" else "light"
+        return improved
+    except Exception:
+        return f"❌ Error improving code:\n{traceback.format_exc()}"
 
-    # store templates for repeated tasks
-    templates = MEMORY[user_id].setdefault("templates", {})
-    # If command repeats -> store as template
-    if command_text.strip():
-        templates_key = re.sub(r"\\s+", "_", command_text.strip())[:50]
-        templates[templates_key] = {"spec": spec, "mode": mode_key, "timestamp": datetime.utcnow().isoformat()}
-        MEMORY[user_id]["templates"] = templates
-        save_memory()
 
-    # Build
-    zip_path = build_project_from_spec(spec, mode=mode_key, include_files=include_files, project_name=f"{MEMORY[user_id]['name']}_{nowtag()}")
+def build_app(name, code_text):
+    """
+    Simulates app creation — saves code, generates structure, and returns build info.
+    """
+    try:
+        build_dir = os.path.join(tempfile.gettempdir(), name.replace(" ", "_"))
+        os.makedirs(build_dir, exist_ok=True)
 
-    status_msg = f"✅ Built project for user '{MEMORY[user_id]['name']}' (mode={mode_key}, framework={framework or 'generic'})."
-    # Response: message + analysis summary + zip path
-    analysis_summary = "No uploaded files." if not analysis else json.dumps(analysis, indent=2)
-    return status_msg + "\\n\\nUploaded files analysis:\\n" + analysis_summary, zip_path
+        file_path = os.path.join(build_dir, "app.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(code_text)
 
-# -------------- Gradio UI --------------
-def reset_memory(user_id):
-    if user_id in MEMORY:
-        MEMORY[user_id] = {
-            "name": "GenBuddy",
-            "gender": "female",
-            "preferences": {"tone": "friendly", "verbosity": "medium"},
-            "templates": {},
-            "history": []
-        }
-        save_memory()
-    return "Memory reset for user: " + user_id
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        return f"🚀 App '{name}' built successfully at {build_dir}\n🕒 {timestamp}"
+    except Exception:
+        return f"❌ Build failed:\n{traceback.format_exc()}"
 
-with gr.Blocks(css="style.css", title="GenBuddy — Intelligent App Builder" :
-    gr.HTML("<div class='app-accent'></div>")
-    gr.Markdown("<h1 class='title'>🌸 GenBuddy — Intelligent App Builder</h1>")
 
-    with gr.Row():
-        with gr.Column(scale=2):
-            user_id = gr.Textbox(label="User ID (optional)", value="default", placeholder="Enter a short id to keep memory separate")
-            name = gr.Textbox(label="Buddy display name (optional)", placeholder="e.g., Aurora")
-            gender = gr.Dropdown(label="Buddy gender", choices=["female", "male", "non-binary"], value="female")
-            set_btn = gr.Button("Set Name & Gender")
-            status = gr.Textbox(label="Status", interactive=False)
+# ============================================================
+#  GRADIO UI
+# ============================================================
 
-            gr.Markdown("### Describe the app or command you want GenBuddy to build")
-            cmd = gr.Textbox(label="Command / App Description", placeholder="e.g., Build a React + Express app with email OTP login", lines=3)
-            framework_choice = gr.Dropdown(label="Explicit framework (optional) — leave blank to auto-detect",
-                                           choices=["", "react", "node", "flask", "django", "dotnet"], value="")
-            mode_choice = gr.Radio(label="Mode", choices=["Light (fast)", "Full (runnable)"], value="Full (runnable)")
-            upload_files = gr.File(label="Upload files to include (optional)", file_count="multiple")
-            run_btn = gr.Button("Build App 🚀")
-            output_text = gr.Textbox(label="Output", lines=6, interactive=False)
-            download_file = gr.File(label="Download Project ZIP", interactive=False)
+with gr.Blocks(css="style.css", title=APP_TITLE) as demo:
+    gr.Markdown(f"# 🧠 {APP_TITLE}\n{APP_DESCRIPTION}")
 
-            # template area
-            gr.Markdown("### Saved Templates")
-            templates_box = gr.Textbox(label="Templates (auto-saved recent commands)", interactive=False, lines=6)
-            refresh_templates = gr.Button("Refresh Templates")
-            reset_btn = gr.Button("Reset Memory")
+    with gr.Tab("💬 Chat & Analyze"):
+        code_input = gr.Textbox(
+            label="Paste your code or repo snippet here",
+            placeholder="Enter Python, JS, or other code...",
+            lines=10,
+        )
+        analyze_btn = gr.Button("🔍 Analyze Code")
+        analyze_output = gr.Markdown()
 
-        with gr.Column(scale=1):
-            gr.Markdown("### Quick actions & tips")
-            gr.Markdown("- Try: `Create login system with email + OTP`")
-            gr.Markdown("- Try: `Make a React dashboard that calls an external API`")
-            gr.Markdown("- Upload sample files to include them in the generated project")
-            gr.Markdown("**Mode**: Full = includes package files (you must run install locally); Light = CDN/minimal stubs.")
-            gr.Markdown("**Safety**: GenBuddy will NOT execute user code in the Space environment — it only generates and packages.")
+        analyze_btn.click(fn=analyze_code, inputs=code_input, outputs=analyze_output)
 
-    # wiring
-    def set_identity(uid, nm, g):
-        ensure_user(uid or "default")
-        MEMORY[uid or "default"]["name"] = nm or MEMORY[uid or "default"]["name"]
-        MEMORY[uid or "default"]["gender"] = g or MEMORY[uid or "default"]["gender"]
-        save_memory()
-        return f"Set identity: {MEMORY[uid or 'default']['name']} ({MEMORY[uid or 'default']['gender']})"
+    with gr.Tab("⚙️ Improve Code"):
+        improve_input = gr.Textbox(
+            label="Code to Improve",
+            placeholder="Paste your raw code here",
+            lines=10,
+        )
+        improve_btn = gr.Button("🚀 Auto-Improve")
+        improve_output = gr.Code(label="Improved Code", language="python")
 
-    def build_and_return(uid, nm, g, mode_sel, framework_sel, cmd_text, uploaded):
-        uid = uid or "default"
-        ensure_user(uid)
-        # map readable mode to internal
-        mode_label = "Full (runnable)" if "Full" in mode_sel else "Light (fast)"
-        out_msg, zip_path = handle_user_interaction(uid, nm, g, mode_sel, framework_sel or None, cmd_text or "", uploaded)
-        # Gradio can return path to file for download
-        return out_msg, zip_path
+        improve_btn.click(fn=improve_code, inputs=improve_input, outputs=improve_output)
 
-    def refresh_templates_fn(uid):
-        uid = uid or "default"
-        ensure_user(uid)
-        templates = MEMORY[uid].get("templates", {})
-        lines = []
-        for k, v in list(templates.items())[-10:]:
-            lines.append(f"{k} -> {v['mode']} @ {v['timestamp']}")
-        return "\\n".join(lines) if lines else "No templates saved yet."
+    with gr.Tab("🏗️ Build App"):
+        app_name = gr.Textbox(label="App Name", placeholder="MyTestApp")
+        code_content = gr.Textbox(
+            label="App Code", placeholder="Paste or generate code to package...", lines=10
+        )
+        build_btn = gr.Button("🛠️ Build App")
+        build_output = gr.Markdown()
 
-    def reset_fn(uid):
-        uid = uid or "default"
-        return reset_memory(uid), ""
+        build_btn.click(fn=build_app, inputs=[app_name, code_content], outputs=build_output)
 
-    set_btn.click(set_identity, inputs=[user_id, name, gender], outputs=[status])
-    run_btn.click(build_and_return, inputs=[user_id, name, gender, mode_choice, framework_choice, cmd, upload_files], outputs=[output_text, download_file])
-    refresh_templates.click(refresh_templates_fn, inputs=[user_id], outputs=[templates_box])
-    reset_btn.click(reset_fn, inputs=[user_id], outputs=[status, templates_box])
+    gr.Markdown("---")
+    gr.Markdown("👾 **GenBuddy** © 2025 — Autonomous AI App Builder.")
 
-launch()
+demo.launch(server_name="0.0.0.0", server_port=7860)