Update app.py

app.py

@@ -5,18 +5,18 @@ import subprocess
 import shutil
 import requests
 import re
+import glob
 
 # --- CONFIGURATION ---
 API_ENDPOINT = "https://gen.pollinations.ai/v1/chat/completions"
-API_KEY = "sk_qDYtDvntvqzjmp23XKVzr9lBXYwYndaR"  # Apki di hui key
+API_KEY = "sk_qDYtDvntvqzjmp23XKVzr9lBXYwYndaR"
 AI_MODEL = "claude"
 
-# Page Config
-st.set_page_config(page_title="AI Android Builder", layout="centered")
-st.title("🤖 AI-Powered Android APK Generator")
-st.markdown("Pollinations AI (Claude) check karega, build karega, aur error aya to khud fix karega.")
+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.")
 
-# --- HELPER: AI API CALL ---
+# --- HELPER: AI API ---
 def ask_claude(system_prompt, user_message):
     headers = {
         "Content-Type": "application/json",
@@ -28,135 +28,113 @@ def ask_claude(system_prompt, user_message):
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": user_message}
         ],
-        "temperature": 0.2  # Low temperature for precise code
+        "temperature": 0.1 # Strictly logic, no creativity
     }
     
     try:
-        response = requests.post(API_ENDPOINT, json=payload, headers=headers, timeout=60)
+        response = requests.post(API_ENDPOINT, json=payload, headers=headers, timeout=90) # Increased timeout
         if response.status_code == 200:
-            return response.json()['choices'][0]['message']['content']
+            return True, response.json()['choices'][0]['message']['content']
         else:
-            return f"Error: {response.text}"
+            return False, f"API Error {response.status_code}"
     except Exception as e:
-        return f"Connection Error: {str(e)}"
+        return False, f"Connection Error: {str(e)}"
 
 # --- HELPER: KEYSTORE ---
 def generate_keystore():
     keystore_path = "debug.keystore"
     if not os.path.exists(keystore_path):
-        cmd = [
+        subprocess.run([
             "keytool", "-genkey", "-v", "-keystore", keystore_path, 
             "-storepass", "android", "-alias", "androiddebugkey", 
             "-keypass", "android", "-keyalg", "RSA", "-keysize", "2048", 
             "-validity", "10000", "-dname", "CN=AndroidDebug,O=Android,C=US"
-        ]
-        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
     return keystore_path
 
-# --- AI LOGIC: PRE-CHECK ---
-def check_project_health(project_root):
-    # Sirf critical files parho taake AI confuse na ho
-    manifest_path = None
-    gradle_path = None
+# --- 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 = []
     
+    # 1. Gradle Files dhoondo
     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:
-            manifest_path = os.path.join(root, "AndroidManifest.xml")
-        if "build.gradle" in files and "app" in root: # App level gradle
-            gradle_path = os.path.join(root, "build.gradle")
+            critical_files.append(os.path.join(root, "AndroidManifest.xml"))
             
-    if not manifest_path or not gradle_path:
-        return "❌ Critical files (Manifest/Gradle) missing. Cannot proceed."
-
-    with open(manifest_path, 'r', encoding='utf-8', errors='ignore') as f:
-        manifest_content = f.read()
-    with open(gradle_path, 'r', encoding='utf-8', errors='ignore') as f:
-        gradle_content = f.read()
-
-    prompt = f"""
-    You are an Android Build Expert. Check these files for critical syntax errors that would stop a build.
-    Do NOT change functionality. Just check if structure is valid.
-    
-    Manifest:
-    {manifest_content[:2000]}
+    # 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))
     
-    Gradle:
-    {gradle_content[:2000]}
+    # 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])
     
-    Reply ONLY with "SAFE" if it looks okay, or "ISSUE: [Explanation]" if bad.
-    """
-    return ask_claude("Analyze code structure.", prompt)
-
-# --- AI LOGIC: AUTO FIX ---
-def attempt_ai_repair(error_log, project_root):
-    # 1. Error log mein se file ka path dhoondo
-    # Format usually: /app/src/main/java/com/example/App.java:15: error: ...
-    match = re.search(r'(/[\w/-]+\.(java|kt|xml|gradle)):(\d+):', error_log)
+    total_files = len(critical_files)
+    fixed_count = 0
     
-    if not match:
-        return False, "AI could not identify the broken file in logs."
+    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})")
         
-    broken_file_path = match.group(1)
-    
-    # Path correction (Absolute vs Relative)
-    if not os.path.exists(broken_file_path):
-        # Try to find it relative to project root
-        found = False
-        file_name = os.path.basename(broken_file_path)
-        for root, dirs, files in os.walk(project_root):
-            if file_name in files:
-                broken_file_path = os.path.join(root, file_name)
-                found = True
-                break
-        if not found:
-            return False, f"File {file_name} not found."
-
-    # 2. Read Broken Code
-    with open(broken_file_path, 'r', encoding='utf-8', errors='ignore') as f:
-        broken_code = f.read()
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+            
+        # --- 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.
         
-    # 3. Ask AI to fix
-    st.info(f"🤖 AI is fixing: **{os.path.basename(broken_file_path)}**")
-    
-    system_prompt = "You are an expert Android Developer. Fix the code error. Maintain original functionality. Output ONLY the full corrected code block without markdown wrappers."
-    user_msg = f"""
-    The build failed with this error:
-    {error_log[:1000]}
-    
-    Here is the broken file content:
-    {broken_code}
-    
-    Return the FULL CORRECTED file content.
-    """
-    
-    fixed_code = ask_claude(system_prompt, user_msg)
-    
-    # Clean AI output (remove ```java etc)
-    fixed_code = fixed_code.replace("```java", "").replace("```kotlin", "").replace("```xml", "").replace("```", "").strip()
-    
-    # 4. Overwrite file
-    try:
-        with open(broken_file_path, 'w', encoding='utf-8') as f:
-            f.write(fixed_code)
-        return True, f"Fixed {os.path.basename(broken_file_path)}"
-    except Exception as e:
-        return False, str(e)
+        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.
+        """
+        
+        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")
+            
+    return fixed_count
 
 # --- MAIN UI ---
 uploaded_file = st.file_uploader("Project ZIP Upload", type=["zip"])
 
 if uploaded_file:
-    if st.button("🚀 AI Check & Build"):
-        status_box = st.status("Initializing...", expanded=True)
+    if st.button("🚀 Strict Build (Guarantee Mode)"):
+        status_box = st.status("Initializing Detective Mode...", expanded=True)
         
         # 1. EXTRACT
-        status_box.write("📂 Extracting files...")
         if os.path.exists("project_extract"): shutil.rmtree("project_extract")
         os.makedirs("project_extract", exist_ok=True)
         with open("uploaded.zip", "wb") as f: f.write(uploaded_file.getbuffer())
         with zipfile.ZipFile("uploaded.zip", "r") as z: z.extractall("project_extract")
         
-        # Root Find
         project_root = None
         for root, dirs, files in os.walk("project_extract"):
             if "gradlew" in files:
@@ -164,52 +142,31 @@ if uploaded_file:
                 break
         
         if not project_root:
-            status_box.update(label="❌ Invalid Project", state="error")
-            st.error("Gradlew not found.")
+            status_box.update(label="❌ Invalid Zip", state="error")
             st.stop()
-            
+
         subprocess.run(["chmod", "+x", os.path.join(project_root, "gradlew")])
 
-        # 2. AI PRE-CHECK
-        status_box.write("🧠 Claude is analyzing project structure...")
-        ai_verdict = check_project_health(project_root)
+        # 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 "SAFE" in ai_verdict or "manifest" in ai_verdict.lower(): # Loose check
-            status_box.write("✅ AI Check Passed.")
+        if fixes > 0:
+            status_box.write(f"✅ AI ne build se pehle **{fixes} files** fix kar di hain.")
         else:
-            status_box.write(f"⚠️ AI Warning: {ai_verdict}")
-            # Hum rukenge nahi, try karenge, shayad build ho jaye
+            status_box.write("✅ Code looks perfect. Proceeding...")
 
-        # 3. BUILD PROCESS LOOP
-        build_success = False
-        attempts = 0
-        max_attempts = 2  # 1 Normal + 1 AI Repair
+        # 3. BUILD
+        status_box.write("🔨 Building APK...")
         
-        while attempts < max_attempts:
-            status_box.write(f"🔨 Building APK (Attempt {attempts+1})...")
-            
-            cmd = ["./gradlew", "assembleRelease", "--no-daemon", "--stacktrace"]
-            result = subprocess.run(cmd, cwd=project_root, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-            
-            if result.returncode == 0:
-                build_success = True
-                break
-            else:
-                attempts += 1
-                if attempts < max_attempts:
-                    status_box.write("❌ Build Failed. Activating AI Repair Agent...")
-                    success, msg = attempt_ai_repair(result.stderr, project_root)
-                    if success:
-                        status_box.write(f"✅ {msg}. Retrying build...")
-                    else:
-                        status_box.write(f"⚠️ AI Repair Failed: {msg}")
-                        break
+        # Force Clean Build
+        cmd = ["./gradlew", "clean", "assembleRelease", "--no-daemon", "--stacktrace"]
+        result = subprocess.run(cmd, cwd=project_root, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         
-        # 4. RESULT HANDLING
-        if build_success:
-            status_box.write("✅ Build Successful! Signing APK...")
+        if result.returncode == 0:
+            status_box.write("✅ Build Successful! Signing now...")
             
-            # Search APK
+            # Find & Sign
             unsigned_apk = None
             for root, dirs, files in os.walk(project_root):
                 for file in files:
@@ -218,27 +175,70 @@ if uploaded_file:
                         break
             
             if unsigned_apk:
-                # SIGNING
                 keystore = generate_keystore()
-                signed_name = "AI_Generated_App.apk"
-                subprocess.run(["zipalign", "-v", "-p", "4", unsigned_apk, "aligned.apk"], stdout=subprocess.DEVNULL)
+                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"
                 ])
                 
-                status_box.update(label="🎉 Process Complete!", state="complete")
-                
+                status_box.update(label="🎉 App Ready!", state="complete")
                 with open(signed_name, "rb") as f:
-                    st.download_button("⬇️ Download AI Verified APK", f, file_name=signed_name, mime="application/vnd.android.package-archive")
+                    st.download_button("⬇️ Download Final APK", f, file_name=signed_name, mime="application/vnd.android.package-archive")
             else:
-                status_box.update(label="❌ File Missing", state="error")
-                st.error("APK generated but file not found.")
+                status_box.error("APK file gum ho gayi.")
         else:
-            status_box.update(label="❌ Fatal Error", state="error")
-            st.error("Build Failed even after AI Repair.")
-            st.text_area("Last Error Log", result.stderr[-2000:], height=300)
+            # 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)
 
-        # Cleanup
         if os.path.exists("uploaded.zip"): os.remove("uploaded.zip")