Update app.py

app.py

@@ -5,16 +5,15 @@ import subprocess
 import shutil
 import requests
 import re
-import glob
 
 # --- CONFIGURATION ---
 API_ENDPOINT = "https://gen.pollinations.ai/v1/chat/completions"
 API_KEY = "sk_qDYtDvntvqzjmp23XKVzr9lBXYwYndaR"
 AI_MODEL = "claude"
 
-st.set_page_config(page_title="Strict AI Android Builder", layout="centered")
-st.title("🕵️‍♂️ Strict AI Auto-Builder")
-st.markdown("Ye system har file ki **Jasoosi** karega aur build se pehle hi errors fix kar dega.")
+st.set_page_config(page_title="Auto-Upgrade Builder", layout="centered")
+st.title("🛡️ AI Builder + Auto-Upgrade Engine")
+st.markdown("Agar project purana hua to system khud usay modernize karega.")
 
 # --- HELPER: AI API ---
 def ask_claude(system_prompt, user_message):
@@ -28,17 +27,15 @@ def ask_claude(system_prompt, user_message):
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": user_message}
         ],
-        "temperature": 0.1 # Strictly logic, no creativity
+        "temperature": 0.1
     }
-    
     try:
-        response = requests.post(API_ENDPOINT, json=payload, headers=headers, timeout=90) # Increased timeout
+        response = requests.post(API_ENDPOINT, json=payload, headers=headers, timeout=60)
         if response.status_code == 200:
             return True, response.json()['choices'][0]['message']['content']
-        else:
-            return False, f"API Error {response.status_code}"
-    except Exception as e:
-        return False, f"Connection Error: {str(e)}"
+        return False, "API Error"
+    except:
+        return False, "Connection Error"
 
 # --- HELPER: KEYSTORE ---
 def generate_keystore():
@@ -52,82 +49,55 @@ def generate_keystore():
         ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     return keystore_path
 
-# --- CORE LOGIC: THE JASOOS (STRICT SCANNER) ---
-def strict_scan_and_fix(project_root, status_box):
-    # Hum in specific files ko target karenge jo 99% errors ki wajah banti hain
-    critical_files = []
+# --- 🛠️ THE MODERNIZER (JADOO) ---
+# Ye function puranay project ko zabardasti naya bana dega
+def force_upgrade_engine(project_root, status_box):
+    status_box.write("🔧 Project Engine bahut purana hai. Zabardasti Upgrade kar raha hun...")
     
-    # 1. Gradle Files dhoondo
+    # 1. Force Gradle Wrapper to 8.0 (Compatible with Java 17)
+    wrapper_props = None
     for root, dirs, files in os.walk(project_root):
-        if "build.gradle" in files:
-            critical_files.append(os.path.join(root, "build.gradle"))
-        if "AndroidManifest.xml" in files:
-            critical_files.append(os.path.join(root, "AndroidManifest.xml"))
+        if "gradle-wrapper.properties" in files:
+            wrapper_props = os.path.join(root, "gradle-wrapper.properties")
+            break
             
-    # 2. Main Java/Kotlin Files (Top 2 largest files utha lo - assuming wahi main logic hai)
-    source_files = []
-    for root, dirs, files in os.walk(project_root):
-        for file in files:
-            if file.endswith(".java") or file.endswith(".kt"):
-                source_files.append(os.path.join(root, file))
-    
-    # Sort by size (descending) and take top 2
-    source_files.sort(key=lambda x: os.path.getsize(x), reverse=True)
-    critical_files.extend(source_files[:2])
-    
-    total_files = len(critical_files)
-    fixed_count = 0
-    
-    for i, file_path in enumerate(critical_files):
-        file_name = os.path.basename(file_path)
-        status_box.write(f"🧐 Auditing: **{file_name}** ({i+1}/{total_files})")
+    if wrapper_props:
+        new_props = """distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+"""
+        with open(wrapper_props, "w") as f:
+            f.write(new_props)
+        status_box.write("✅ Gradle Wrapper set to 8.0")
         
-        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
-            content = f.read()
+    # 2. Update Classpath in build.gradle
+    root_gradle = None
+    for root, dirs, files in os.walk(project_root):
+        if "build.gradle" in files and "app" not in root: # Root level
+            root_gradle = os.path.join(root, "build.gradle")
+            break
             
-        # --- PROMPT: STRICT ENVIRONMENT MATCHING ---
-        system_prompt = """
-        You are a Senior Android Architect auditing code for a CI/CD server.
-        Server Specs: Linux, Java 17, Android SDK 33.
-        
-        Rules:
-        1. Fix any deprecated Gradle plugins (use valid versions for Java 17).
-        2. Ensure compileSdkVersion is 33 or 34.
-        3. Fix Manifest package name errors.
-        4. In Java/Kotlin, fix syntax errors strictly.
-        5. DO NOT remove main logic, only fix structure/syntax.
-        
-        Output:
-        If the code is 100% PERFECT, reply exactly: "NO_CHANGES_NEEDED"
-        If there is ANY issue, reply with the FULL CORRECTED CODE only. No markdown.
-        """
+    if root_gradle:
+        with open(root_gradle, "r") as f: content = f.read()
+        # Regex to replace old classpath with new one
+        new_content = re.sub(r"classpath\s+['\"]com.android.tools.build:gradle:.*?['\"]", 
+                             "classpath 'com.android.tools.build:gradle:8.0.0'", content)
         
-        user_msg = f"Check this file content:\n\n{content}"
-        
-        success, response = ask_claude(system_prompt, user_msg)
-        
-        if success:
-            if "NO_CHANGES_NEEDED" not in response:
-                # AI ne changes kiye hain
-                cleaned_code = response.replace("```gradle", "").replace("```java", "").replace("```xml", "").replace("```kotlin", "").replace("```", "").strip()
-                
-                # Safety check: Code empty to nahi?
-                if len(cleaned_code) > 10:
-                    with open(file_path, 'w', encoding='utf-8') as f:
-                        f.write(cleaned_code)
-                    fixed_count += 1
-                    status_box.write(f"🛠️ **Fixed Issues in {file_name}**")
-        else:
-            status_box.write(f"⚠️ AI Skip ({file_name}): API Error")
+        # Add google() if missing
+        if "google()" not in new_content:
+            new_content = new_content.replace("repositories {", "repositories {\n        google()\n        mavenCentral()")
             
-    return fixed_count
+        with open(root_gradle, "w") as f: f.write(new_content)
+        status_box.write("✅ Build Plugin updated to 8.0.0")
 
-# --- MAIN UI ---
+# --- MAIN LOGIC ---
 uploaded_file = st.file_uploader("Project ZIP Upload", type=["zip"])
 
 if uploaded_file:
-    if st.button("🚀 Strict Build (Guarantee Mode)"):
-        status_box = st.status("Initializing Detective Mode...", expanded=True)
+    if st.button("🚀 Start Auto-Build"):
+        status_box = st.status("Initializing...", expanded=True)
         
         # 1. EXTRACT
         if os.path.exists("project_extract"): shutil.rmtree("project_extract")
@@ -142,103 +112,88 @@ if uploaded_file:
                 break
         
         if not project_root:
-            status_box.update(label="❌ Invalid Zip", state="error")
+            st.error("Gradlew not found.")
             st.stop()
 
         subprocess.run(["chmod", "+x", os.path.join(project_root, "gradlew")])
 
-        # 2. STRICT AI AUDIT (The Jasoos Step)
-        status_box.write("🕵️‍♂️ Starting Deep Scan (Scanning all critical files)...")
-        fixes = strict_scan_and_fix(project_root, status_box)
-        
-        if fixes > 0:
-            status_box.write(f"✅ AI ne build se pehle **{fixes} files** fix kar di hain.")
-        else:
-            status_box.write("✅ Code looks perfect. Proceeding...")
-
-        # 3. BUILD
-        status_box.write("🔨 Building APK...")
-        
-        # Force Clean Build
+        # 2. ATTEMPT 1: NORMAL BUILD
+        status_box.write("🔨 Attempt 1: Building with default settings...")
         cmd = ["./gradlew", "clean", "assembleRelease", "--no-daemon", "--stacktrace"]
         result = subprocess.run(cmd, cwd=project_root, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         
+        success = False
         if result.returncode == 0:
-            status_box.write("✅ Build Successful! Signing now...")
+            success = True
+        else:
+            # 3. FAILURE DETECTED -> UPGRADE ENGINE -> ATTEMPT 2
+            status_box.write("❌ Attempt 1 Failed. Checking if engine is old...")
+            
+            # Agar 'Daemon' ya 'Java' ka error hai to Modernizer chalao
+            logs = result.stderr
+            if "Daemon" in logs or "Java" in logs or "Minimum supported Gradle" in logs:
+                force_upgrade_engine(project_root, status_box)
+                
+                status_box.write("🔄 Attempt 2: Rebuilding with NEW Engine...")
+                result = subprocess.run(cmd, cwd=project_root, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                
+                if result.returncode == 0:
+                    success = True
+                else:
+                    # 4. STILL FAILING -> USE AI FOR CODE ERRORS -> ATTEMPT 3
+                    status_box.write("❌ Attempt 2 Failed. Now checking Code Errors with AI...")
+                    
+                    logs = result.stderr
+                    # Find broken file from logs
+                    match = re.search(r'(/[\w/-]+\.(java|kt|xml|gradle)):(\d+):', logs)
+                    if match:
+                        broken_file = match.group(1)
+                        # Fix path
+                        if not os.path.exists(broken_file):
+                            for r, d, f in os.walk(project_root):
+                                if os.path.basename(broken_file) in f:
+                                    broken_file = os.path.join(r, os.path.basename(broken_file))
+                                    break
+                                    
+                        if os.path.exists(broken_file):
+                            with open(broken_file, 'r') as f: code = f.read()
+                            status_box.write(f"🤖 AI Fixing: {os.path.basename(broken_file)}")
+                            
+                            prompt = "Fix this compile error strictly. Return only code."
+                            msg = f"Error: {logs[-1000:]}\n\nCode:\n{code}"
+                            ok, fixed_code = ask_claude(prompt, msg)
+                            
+                            if ok:
+                                clean_code = fixed_code.replace("```java","").replace("```","").strip()
+                                with open(broken_file, 'w') as f: f.write(clean_code)
+                                status_box.write("✅ Code Fixed. Final Retry...")
+                                
+                                result = subprocess.run(cmd, cwd=project_root, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+                                if result.returncode == 0: success = True
+
+        # 5. FINAL RESULT
+        if success:
+            status_box.update(label="✅ Build Successful! Signing...", state="complete")
             
-            # Find & Sign
-            unsigned_apk = None
+            # Find APK
+            target_apk = None
             for root, dirs, files in os.walk(project_root):
                 for file in files:
                     if file.endswith(".apk") and "release" in file:
-                        unsigned_apk = os.path.join(root, file)
+                        target_apk = os.path.join(root, file)
                         break
             
-            if unsigned_apk:
+            if target_apk:
                 keystore = generate_keystore()
-                signed_name = "Pro_Signed_App.apk"
-                
-                # Zipalign
-                subprocess.run(["zipalign", "-v", "-p", "4", unsigned_apk, "aligned.apk"], stdout=subprocess.DEVNULL)
-                # Sign
-                subprocess.run([
-                    "apksigner", "sign", "--ks", keystore, "--ks-pass", "pass:android",
-                    "--out", signed_name, "aligned.apk"
-                ])
+                signed = "Auto_Fixed_App.apk"
+                subprocess.run(["zipalign", "-v", "-p", "4", target_apk, "aligned.apk"], stdout=subprocess.DEVNULL)
+                subprocess.run(["apksigner", "sign", "--ks", keystore, "--ks-pass", "pass:android", "--out", signed, "aligned.apk"])
                 
-                status_box.update(label="🎉 App Ready!", state="complete")
-                with open(signed_name, "rb") as f:
-                    st.download_button("⬇️ Download Final APK", f, file_name=signed_name, mime="application/vnd.android.package-archive")
-            else:
-                status_box.error("APK file gum ho gayi.")
+                with open(signed, "rb") as f:
+                    st.download_button("⬇️ Download 100% Working APK", f, file_name=signed)
         else:
-            # 4. EMERGENCY REPAIR (Agar Jasoos se bhi kuch bach gaya ho)
-            status_box.write("⚠️ Build Error! Activating Emergency Repair...")
-            
-            # Simple Repair Logic for last attempt
-            error_log = result.stderr
-            match = re.search(r'(/[\w/-]+\.(java|kt|xml|gradle)):(\d+):', error_log)
-            if match:
-                broken_file = match.group(1)
-                # Relative path fix
-                if not os.path.exists(broken_file):
-                     for root, dirs, files in os.walk(project_root):
-                        if os.path.basename(broken_file) in files:
-                            broken_file = os.path.join(root, os.path.basename(broken_file))
-                            break
-                
-                if os.path.exists(broken_file):
-                    status_box.write(f"🚑 Fixing leftover error in: {os.path.basename(broken_file)}")
-                    with open(broken_file, 'r') as f: content = f.read()
-                    
-                    # Ask AI one last time
-                    s_prompt = "Fix this specific build error in the code. Output ONLY code."
-                    u_msg = f"Error: {error_log[-500:]}\nCode: {content}"
-                    success, fixed = ask_claude(s_prompt, u_msg)
-                    
-                    if success:
-                        clean = fixed.replace("```java", "").replace("```", "").strip()
-                        with open(broken_file, 'w') as f: f.write(clean)
-                        
-                        # Last Retry
-                        status_box.write("🔄 Final Retry...")
-                        subprocess.run(cmd, cwd=project_root, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-                        
-                        # Check again
-                        final_apk = None
-                        for root, dirs, files in os.walk(project_root):
-                            for file in files:
-                                if file.endswith(".apk") and "release" in file:
-                                    final_apk = os.path.join(root, file)
-                                    break
-                        if final_apk:
-                            status_box.update(label="🎉 Saved by AI!", state="complete")
-                            with open(final_apk, "rb") as f:
-                                st.download_button("⬇️ Download Rescued APK", f, file_name="rescued_app.apk")
-                            st.stop()
-            
-            status_box.update(label="❌ Total Failure", state="error")
-            st.error("AI couldn't fix it automatically.")
-            st.text_area("Logs", result.stderr[-2000:], height=300)
+            status_box.update(label="❌ Fatal Error", state="error")
+            st.error("System could not auto-fix this project.")
+            st.text_area("Last Logs", result.stderr[-2000:], height=300)
 
         if os.path.exists("uploaded.zip"): os.remove("uploaded.zip")