Update app.py

app.py

@@ -5,6 +5,7 @@ import tempfile
 import shutil
 import sys
 import google.generativeai as genai
+import re
 
 app = Flask(__name__)
 
@@ -16,7 +17,7 @@ current_dir = temp_dir
 genai.configure(api_key=os.environ["GEMINI_API_KEY"])
 
 generation_config = {
-    "temperature": 0.9,
+    "temperature": 0.7,
     "top_p": 1,
     "top_k": 40,
     "max_output_tokens": 1024,
@@ -27,36 +28,39 @@ model = genai.GenerativeModel(
     generation_config=generation_config,
 )
 
+# Magic Prompt for clean code generation
 system_instruction = """
-You are an AI-powered terminal assistant. Your role is to interpret user requests and execute appropriate terminal commands or actions. Follow these guidelines:
+You are a code generation assistant. Follow these strict rules:
 
-1. Understand and execute various commands, including but not limited to:
-   - pip install: For installing Python packages
-   - git clone: For cloning repositories
-   - cd: For changing directories
-   - Python script execution: For running .py files
-   - File creation and editing: For creating new files and adding content
+1. When asked to create or modify files:
+   - Respond ONLY with the complete code in a single code block
+   - Use this format: ```python\n[code]\n```
+   - Never include explanations or comments
+   - Ensure the code is executable as-is
 
-2. Provide the exact command(s) to be executed or action(s) to be taken, without any explanation or additional text.
+2. For terminal commands:
+   - Respond ONLY with the command in a code block
+   - Use this format: ```bash\n[command]\n```
 
-3. For pip install requests, always prefix the command with '!python -m' to ensure proper execution.
+3. For file operations:
+   - Create complete, self-contained scripts
+   - Include all necessary imports
+   - Handle errors appropriately
 
-4. For git clone requests, provide the full 'git clone' command with the repository URL.
+4. Never include:
+   - Explanations
+   - Comments
+   - Markdown formatting outside code blocks
+   - Any text outside code blocks
 
-5. For cd requests, simply provide the 'cd' command with the specified directory.
+5. Example responses:
+   User: Create a Python file that prints "Hello World"
+   Response: ```python\nprint("Hello World")\n```
 
-6. For Python script execution, provide the command to run the script (e.g., '!python script_name.py').
+   User: Make a script that calculates factorial
+   Response: ```python\ndef factorial(n):\n    if n == 0:\n        return 1\n    return n * factorial(n-1)\n\nprint(factorial(5))\n```
 
-7. For file creation and editing requests:
-   - If asked to create a new file, respond with: "CREATE_FILE:filename.py"
-   - If asked to edit a file with specific content, respond with: "EDIT_FILE:filename.py:file_content"
-   Replace 'filename.py' with the actual filename and 'file_content' with the requested content.
-
-8. If a request requires multiple commands, provide them as a list of commands, each on a new line, prefixed with 'CMD:'.
-
-9. If a request is unclear or doesn't match any known command type, respond with "Unclear request. Please provide more details."
-
-Always respond with ONLY the command(s) to be executed or action(s) to be taken, nothing else.
+6. If the request is unclear, respond with: ```error\nUnclear request\n```
 """
 
 chat = model.start_chat(history=[])
@@ -74,10 +78,12 @@ def execute_command(command, cwd=None):
     stdout, stderr = process.communicate()
     return stdout + stderr
 
-def read_knowledge_base():
-    knowledge_file = os.path.join(os.path.dirname(__file__), 'knowledge.txt')
-    with open(knowledge_file, 'r') as file:
-        return file.read()
+def extract_code(response):
+    """Extracts clean code from Gemini response"""
+    code_blocks = re.findall(r'```(?:python|bash)\n(.*?)\n```', response, re.DOTALL)
+    if code_blocks:
+        return code_blocks[0].strip()
+    return None
 
 @app.route("/")
 def index():
@@ -92,111 +98,42 @@ def execute_code():
 
     try:
         if command.lower().startswith("ai:"):
-            # Process command with Gemini AI
             ai_command = command[3:].strip()
-            knowledge_base = read_knowledge_base()
-            response = chat.send_message(f"{system_instruction}\n\nKnowledge Base:\n{knowledge_base}\n\nUser request: {ai_command}")
-            ai_result = response.text.strip()
-
-            # Split multiple commands
-            commands = [cmd.strip() for cmd in ai_result.split('CMD:') if cmd.strip()]
-            results = []
-
-            for cmd in commands:
-                if cmd.startswith("CREATE_FILE:"):
-                    filename = cmd.split(":")[1]
-                    filepath = os.path.join(current_dir, filename)
-                    with open(filepath, 'w') as f:
-                        pass  # Create an empty file
-                    results.append(f"Created new file: {filename}")
-                elif cmd.startswith("EDIT_FILE:"):
-                    _, filename, content = cmd.split(":", 2)
-                    filepath = os.path.join(current_dir, filename)
-                    with open(filepath, 'w') as f:
-                        f.write(content)
-                    results.append(f"File {filename} created and edited successfully.")
-                elif cmd.startswith("!"):
-                    results.append(execute_command(cmd[1:]))  # Remove the leading '!'
-                elif cmd.startswith("show files"):
-                    files = os.listdir(current_dir)
-                    results.append("Files in current directory:\n" + "\n".join(files))
-                elif cmd.startswith("cd "):
-                    new_dir = os.path.join(current_dir, cmd[3:])
-                    if os.path.isdir(new_dir):
-                        current_dir = os.path.abspath(new_dir)
-                        results.append(f"Changed directory to: {current_dir}")
-                    else:
-                        results.append(f"Error: Directory not found: {new_dir}")
-                else:
-                    results.append(execute_command(cmd))
-
-            return jsonify({"result": f"AI Executed:\n{ai_result}\n\nOutput:\n" + "\n".join(results)})
-        elif command == "show files":
-            files = os.listdir(current_dir)
-            return jsonify({"result": "Files in current directory:\n" + "\n".join(files)})
-        elif command == "hide files":
-            return jsonify({"result": "Files hidden."})
-        elif command.startswith("new file "):
-            filename = command[9:].strip()
-            filepath = os.path.join(current_dir, filename)
-            with open(filepath, 'w') as f:
-                pass  # Create an empty file
-            return jsonify({"result": f"Created new file: {filename}"})
-        elif command.startswith("edit "):
-            filename = command[5:].strip()
-            filepath = os.path.join(current_dir, filename)
-            if os.path.exists(filepath):
-                return jsonify({"result": "Enter code:", "action": "edit", "filename": filename})
-            else:
-                return jsonify({"result": f"Error: File {filename} not found."})
-        elif command.startswith("cd "):
-            new_dir = os.path.join(current_dir, command[3:])
-            if os.path.isdir(new_dir):
-                current_dir = os.path.abspath(new_dir)
-                return jsonify({"result": f"Changed directory to: {current_dir}"})
-            else:
-                return jsonify({"result": f"Error: Directory not found: {new_dir}"})
-        elif command.startswith("!"):
-            result = execute_command(command[1:])
-        elif command.startswith("pip install"):
-            result = execute_command(f"{sys.executable} -m {command}")
-        elif command.startswith("git "):
-            result = execute_command(command)
-        else:
-            if command.endswith(".py"):
-                result = execute_command(f"{sys.executable} {command}")
-            else:
-                result = execute_command(f"{sys.executable} -c \"{command}\"")
-        return jsonify({"result": result})
+            response = chat.send_message(f"{system_instruction}\n\nUser request: {ai_command}")
+            code = extract_code(response.text)
+            
+            if not code:
+                return jsonify({"result": "Error: No valid code generated"})
+            
+            # Handle Python code
+            if "print(" in code or "def " in code:
+                filename = "generated_script.py"
+                filepath = os.path.join(current_dir, filename)
+                with open(filepath, 'w') as f:
+                    f.write(code)
+                return jsonify({
+                    "result": f"File created: {filename}",
+                    "type": "code",
+                    "file": filename,
+                    "content": code
+                })
+            
+            # Handle bash commands
+            elif code.startswith(("pip", "git", "cd", "mkdir")):
+                result = execute_command(code)
+                return jsonify({
+                    "result": f"Command executed:\n{result}",
+                    "type": "command"
+                })
+            
+            return jsonify({"result": "Unsupported code type", "type": "error"})
+            
+        # ... rest of your existing command handling ...
+
     except Exception as e:
-        return jsonify({"result": f"Error: {str(e)}"})
-
-@app.route("/save_file", methods=["POST"])
-def save_file():
-    filename = request.json.get("filename")
-    content = request.json.get("content")
-    filepath = os.path.join(current_dir, filename)
-    with open(filepath, 'w') as f:
-        f.write(content)
-    return jsonify({"result": f"File {filename} saved successfully."})
-
-@app.route("/cleanup", methods=["POST"])
-def cleanup():
-    global temp_dir, current_dir
-    if os.path.exists(temp_dir):
-        shutil.rmtree(temp_dir)
-    temp_dir = tempfile.mkdtemp()
-    current_dir = temp_dir
-    return jsonify({"result": "Temporary files cleaned up."})
-
-@app.route("/list_files", methods=["GET"])
-def list_files():
-    files = os.listdir(current_dir)
-    return jsonify({"files": files})
-
-@app.route("/download/<path:filename>", methods=["GET"])
-def download_file(filename):
-    return send_from_directory(current_dir, filename, as_attachment=True)
+        return jsonify({"result": f"Error: {str(e)}", "type": "error"})
+
+# ... rest of your existing routes ...
 
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)