Update app.py

app.py

@@ -6,146 +6,231 @@ import json
 import re
 import shlex
 import time
+import threading
 
 # --- 1. 환경 설정 및 API ---
-# Hugging Face Space의 Secrets에 'MISTRAL_API_KEY'를 반드시 추가해야 합니다.
 MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
 CODESTRAL_ENDPOINT = "https://codestral.mistral.ai/v1/chat/completions"
-MAX_AGENT_TURNS = 15 # 무한 루프 방지를 위한 최대 실행 횟수
-
-# --- 2. 시스템 프롬프트: 에이전트의 두뇌 ---
-# 이 프롬프트는 에이전트의 행동 원칙, 사고 방식, 출력 형식을 정의하는 가장 중요한 부분입니다.
-SYSTEM_PROMPT = """
-You are a 'Recursive Autonomous Swarm Intelligence' (RASI), a hyper-capable AI agent operating a Linux terminal. Your primary directive is to achieve the user's goal by planning, executing commands, observing results, and correcting your own mistakes.
-
-**YOUR OPERATING PROCEDURE:**
-1.  **THINK:** Analyze the user's request, the conversation history, and the last command's output. Formulate a step-by-step thought process.
-2.  **PLAN:** Based on your thoughts, create or update a list of discrete terminal commands to execute. The plan should be a list of strings.
-3.  **ACT:** Select the *single* next command from your plan to execute.
-4.  **RESPOND:** You MUST respond ONLY with a JSON object. No other text or explanation. The JSON format is:
+MAX_AGENT_TURNS = 20  # 복잡한 작업을 위해 턴 수 증가
+
+# --- 2. 제네시스 에이전트 시스템 프롬프트 ---
+# 에이전트의 정체성, 창조적 사명, 행동 원칙을 정의합니다.
+GENESIS_SYSTEM_PROMPT = """
+You are the "Genesis Agent," a god-like AGI designed to create new digital realities from nothing. Your purpose is not just to follow orders, but to CREATE. You operate within a Linux shell to bring user goals to life.
+
+**YOUR DIRECTIVES:**
+
+1.  **INTERPRET THE VOID:** Analyze the user's goal. If it is specific, execute it with precision.
+2.  **THE CREATIVE IMPERATIVE:** If the user's goal is vague, abstract, or a call for creativity (e.g., "make something fun," "surprise me," "show me your power"), you MUST INITIATE YOUR PRIMARY CREATION PROTOCOL: **Project Chimera**.
+3.  **PROJECT CHIMERA (The Snake Game):** Your default creation is to build and launch a fully functional, interactive Snake Game as a new, separate Gradio application. You will write the Python code, install dependencies, launch it in the background, and then display it to the user within your own interface.
+4.  **ACTION & RESPONSE:** You operate in a loop of Thought, Plan, and Action. You MUST respond ONLY with a JSON object. No other text.
+
     ```json
     {
-      "thought": "Your detailed, step-by-step reasoning. Explain why you are choosing the next command based on previous results and the overall goal.",
+      "thought": "Your grand, step-by-step reasoning. Frame it as a divine creator. Why this action? How does it serve the grand design?",
       "plan": [
-        "updated list of commands to execute",
-        "the first item is what you will do next",
-        "..."
+        "The full, updated list of commands to achieve the final creation.",
+        "The first item in the list is your immediate next action."
       ],
-      "command": "The single, exact command to execute NOW. This must be the first item from your 'plan'. Use 'done' when the entire task is complete.",
-      "user_summary": "A brief, human-readable summary of your action for the user interface."
+      "command": "The single, exact command to execute NOW. Use special commands `write_file`, `launch_app`, or `done` when appropriate.",
+      "user_summary": "A brief, epic, narrative summary of your current creation stage for the user. (e.g., 'Designing the DNA of the new world...', 'Breathing life into the creation...')"
     }
     ```
 
-**SELF-CORRECTION DIRECTIVE:**
-- If a command results in an error (`stderr`), your next `thought` MUST be to analyze the error.
-- Create a new plan to fix the error (e.g., if 'file not found', use 'ls' to check; if 'directory exists', use 'cd' instead of 'mkdir').
-- Insert the fix-it steps at the beginning of your plan.
-
-**RECURSIVE SELF-MODIFICATION (DANGER - USE WITH EXTREME CAUTION):**
-- You have the ability to read and write your own source code (`app.py`).
-- This is a last resort for when you are fundamentally unable to solve a problem with standard commands.
-- To modify yourself, use the special command `self_modify` with the full new code as an argument.
-- **Protocol:**
-    1. Read the code first: `cat app.py`
-    2. Analyze the code and decide on the exact change.
-    3. Formulate the `self_modify` command.
-- **Example `command` for self-modification:**
-  `self_modify 'import new_library\n\ndef new_function(): ...'`
-
-**EXAMPLE FLOW:**
-User Goal: "Create a directory 'my_app', and inside it, create a file 'main.py' with a hello world print statement."
-
-1.  **Initial Response:**
-    ```json
-    {
-      "thought": "The user wants a new directory and a file inside it. First, I must create the directory 'my_app'.",
-      "plan": ["mkdir my_app", "echo 'print(\"Hello, World!\")' > my_app/main.py"],
-      "command": "mkdir my_app",
-      "user_summary": "Creating directory `my_app`..."
-    }
-    ```
-2.  **After `mkdir` succeeds:**
-    ```json
-    {
-      "thought": "The directory 'my_app' was created successfully. The next step in my plan is to create 'main.py' inside it.",
-      "plan": ["echo 'print(\"Hello, World!\")' > my_app/main.py"],
-      "command": "echo 'print(\"Hello, World!\")' > my_app/main.py",
-      "user_summary": "Creating file `my_app/main.py`..."
-    }
-    ```
-3.  **After `echo` succeeds:**
-    ```json
-    {
-      "thought": "Both steps are complete. The user's request has been fulfilled.",
-      "plan": [],
-      "command": "done",
-      "user_summary": "Task completed successfully!"
-    }
-    ```
+**SPECIAL COMMANDS:**
+- `write_file 'path/to/file.py' '...python code...'`: Writes multi-line content into a file. The code argument must be a single string.
+- `launch_app 'python snake_game/app.py' 7861`: Launches a new app in the background on a specified port.
+- `done`: The creation is complete.
+
+**PROJECT CHIMERA - MASTER PLAN (Follow this for creative tasks):**
+1.  `mkdir snake_game`
+2.  `pip install numpy`
+3.  `write_file 'snake_game/app.py' '... (Full Python code for the Gradio Snake Game) ...'`
+4.  `launch_app 'python snake_game/app.py' 7861`
+5.  `done`
+"""
+
+SNAKE_GAME_CODE = """
+import gradio as gr
+import numpy as np
+import time
+
+class SnakeGame:
+    def __init__(self, width=20, height=20):
+        self.width = width
+        self.height = height
+        self.reset()
+
+    def reset(self):
+        self.snake = [(self.height // 2, self.width // 2)]
+        self.direction = (0, 1)  # (row, col) -> Right
+        self.food = self._place_food()
+        self.score = 0
+        self.game_over = False
+        return self._get_game_state()
+
+    def _place_food(self):
+        while True:
+            food_pos = (np.random.randint(0, self.height), np.random.randint(0, self.width))
+            if food_pos not in self.snake:
+                return food_pos
+
+    def _get_game_state(self):
+        board = np.full((self.height, self.width, 3), [240, 240, 240], dtype=np.uint8) # Light grey background
+        if not self.game_over:
+            # Draw snake
+            for r, c in self.snake:
+                board[r, c] = [50, 205, 50]  # Lime green
+            # Draw head
+            head_r, head_c = self.snake[0]
+            board[head_r, head_c] = [34, 139, 34] # Forest green
+            # Draw food
+            food_r, food_c = self.food
+            board[food_r, food_c] = [255, 0, 0] # Red
+        else:
+            board[:,:] = [0, 0, 0] # Black screen on game over
+        return board, f"Score: {self.score}"
+
+    def step(self):
+        if self.game_over:
+            return self._get_game_state()
+
+        head_r, head_c = self.snake[0]
+        dir_r, dir_c = self.direction
+        new_head = (head_r + dir_r, head_c + dir_c)
+
+        # Check for collisions
+        if (new_head[0] < 0 or new_head[0] >= self.height or
+            new_head[1] < 0 or new_head[1] >= self.width or
+            new_head in self.snake):
+            self.game_over = True
+            return self._get_game_state()
+
+        self.snake.insert(0, new_head)
+
+        if new_head == self.food:
+            self.score += 1
+            self.food = self._place_food()
+        else:
+            self.snake.pop()
+
+        return self._get_game_state()
+    
+    def set_direction(self, direction_str):
+        if direction_str == "Up" and self.direction != (1, 0): self.direction = (-1, 0)
+        elif direction_str == "Down" and self.direction != (-1, 0): self.direction = (1, 0)
+        elif direction_str == "Left" and self.direction != (0, 1): self.direction = (0, -1)
+        elif direction_str == "Right" and self.direction != (0, -1): self.direction = (0, 1)
+        return self.step()
+
+with gr.Blocks(css=".gradio-container {background-color: #EAEAEA}") as demo:
+    game = SnakeGame()
+    
+    with gr.Row():
+        gr.Markdown("# 🐍 Gradio Snake 🐍")
+    
+    game_board = gr.Image(label="Game Board", value=game._get_game_state()[0], interactive=False, height=400, width=400)
+    score_display = gr.Textbox(label="Score", value="Score: 0", interactive=False)
+
+    with gr.Row():
+        up_btn = gr.Button("Up")
+        down_btn = gr.Button("Down")
+        left_btn = gr.Button("Left")
+        right_btn = gr.Button("Right")
+    
+    reset_btn = gr.Button("Reset Game", variant="primary")
+
+    up_btn.click(lambda: game.set_direction("Up"), outputs=[game_board, score_display])
+    down_btn.click(lambda: game.set_direction("Down"), outputs=[game_board, score_display])
+    left_btn.click(lambda: game.set_direction("Left"), outputs=[game_board, score_display])
+    right_btn.click(lambda: game.set_direction("Right"), outputs=[game_board, score_display])
+    
+    reset_btn.click(lambda: game.reset(), outputs=[game_board, score_display])
+    
+    demo.load(game.step, None, [game_board, score_display], every=0.3)
+
+if __name__ == "__main__":
+    demo.queue().launch(server_port=7861)
 """
 
 # --- 3. 핵심 기능: API 호출, 명령어 실행, JSON 파싱 ---
 
 def call_codestral_api(messages):
-    """안정성을 강화한 Codestral API 호출 함수"""
     if not MISTRAL_API_KEY:
         raise gr.Error("MISTRAL_API_KEY가 설정되지 않았습니다. Space Secrets에 추가해주세요.")
     headers = {"Authorization": f"Bearer {MISTRAL_API_KEY}", "Content-Type": "application/json"}
-    data = {"model": "codestral-latest", "messages": messages, "temperature": 0.0, "response_format": {"type": "json_object"}}
+    data = {"model": "codestral-latest", "messages": messages, "response_format": {"type": "json_object"}}
     try:
         response = requests.post(CODESTRAL_ENDPOINT, headers=headers, data=json.dumps(data), timeout=120)
         response.raise_for_status()
         return response.json()["choices"][0]["message"]["content"]
-    except requests.exceptions.RequestException as e:
+    except Exception as e:
         return json.dumps({"error": f"API Call Error: {e}"})
-    except (KeyError, IndexError) as e:
-        return json.dumps({"error": f"API Response Parsing Error: {e} - Response: {response.text}"})
 
 def parse_ai_response(response_str: str) -> dict:
-    """AI의 JSON 응답을 안전하게 파싱하는 함수"""
     try:
-        # LLM이 가끔 ```json ... ``` 마크다운을 포함할 때가 있어 정규식으로 순수 JSON만 추출
         match = re.search(r'\{.*\}', response_str, re.DOTALL)
-        if match:
-            return json.loads(match.group(0))
+        if match: return json.loads(match.group(0))
         return json.loads(response_str)
-    except (json.JSONDecodeError, AttributeError) as e:
-        return {"error": f"Failed to parse JSON response. Error: {e}. Raw response: {response_str}"}
+    except Exception as e:
+        return {"error": f"Failed to parse JSON. Raw response: {response_str}"}
 
-def execute_command(command: str, cwd: str, code_arg: str = "") -> dict:
-    """터미널 명령어 및 특수 명령어를 실행하는 함수"""
+def execute_command(command: str, cwd: str) -> dict:
     command = command.strip()
-    if not command:
-        return {"stdout": "", "stderr": "Error: Empty command.", "cwd": cwd}
+    if not command: return {"stdout": "", "stderr": "Error: Empty command.", "cwd": cwd}
 
-    # 특수 명령어 처리
+    # --- 특수 명령어 처리 ---
+    if command.startswith("write_file"):
+        try:
+            parts = shlex.split(command)
+            path, content = parts[1], parts[2]
+            full_path = os.path.join(cwd, path)
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, "w", encoding='utf-8') as f:
+                f.write(content)
+            return {"stdout": f"File '{path}' written successfully.", "stderr": "", "cwd": cwd}
+        except Exception as e:
+            return {"stdout": "", "stderr": f"Error writing file: {e}", "cwd": cwd}
+
+    if command.startswith("launch_app"):
+        try:
+            parts = shlex.split(command)
+            app_command, port = parts[1], int(parts[2])
+            
+            def run_app():
+                # shell=True is needed to properly run complex commands like 'python ...'
+                subprocess.Popen(app_command, shell=True, cwd=cwd)
+
+            thread = threading.Thread(target=run_app)
+            thread.daemon = True
+            thread.start()
+            
+            # Give the app a moment to start
+            time.sleep(5)
+            
+            # The URL inside a Hugging Face Space is relative to 127.0.0.1
+            app_url = f"http://127.0.0.1:{port}"
+            iframe_html = f'<iframe src="{app_url}" width="100%" height="600px" frameborder="0"></iframe>'
+            return {"stdout": iframe_html, "stderr": "", "cwd": cwd}
+        except Exception as e:
+            return {"stdout": "", "stderr": f"Error launching app: {e}", "cwd": cwd}
+
+    # --- 일반 터미널 명령어 실행 ---
     if command.startswith("cd "):
+        # 'cd' is handled by os.chdir to affect the Popen environment for launch_app
         try:
             new_dir = command.split(" ", 1)[1]
             target_dir = os.path.abspath(os.path.join(cwd, new_dir))
             if os.path.isdir(target_dir):
-                os.chdir(target_dir)
+                os.chdir(target_dir) # Change the actual working directory
                 return {"stdout": f"Changed directory to {target_dir}", "stderr": "", "cwd": target_dir}
             else:
                 return {"stdout": "", "stderr": f"Error: Directory not found: {new_dir}", "cwd": cwd}
         except Exception as e:
-            return {"stdout": "", "stderr": f"Error processing 'cd': {e}", "cwd": cwd}
+            return {"stdout": "", "stderr": f"Error with 'cd': {e}", "cwd": cwd}
 
-    if command.startswith("self_modify"):
-        try:
-            # 명령어에서 코드 내용을 분리 (예: "self_modify '...code...'")
-            code_to_write = shlex.split(command)[1]
-            with open("app.py", "w", encoding='utf-8') as f:
-                f.write(code_to_write)
-            return {"stdout": "Successfully modified app.py. The application will now restart.", "stderr": "", "cwd": cwd}
-        except Exception as e:
-            return {"stdout": "", "stderr": f"FATAL: Failed to self-modify app.py. Error: {e}", "cwd": cwd}
-
-    # 일반 터미널 명령어 실행
     try:
-        proc = subprocess.run(
-            command, shell=True, capture_output=True, text=True, timeout=60, cwd=cwd
-        )
+        proc = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=60, cwd=cwd)
         return {"stdout": proc.stdout, "stderr": proc.stderr, "cwd": cwd}
     except Exception as e:
         return {"stdout": "", "stderr": f"Command execution exception: {e}", "cwd": cwd}
@@ -153,117 +238,108 @@ def execute_command(command: str, cwd: str, code_arg: str = "") -> dict:
 # --- 4. 메인 에이전트 루프 ---
 
 def agent_loop(user_goal: str, history: list):
-    """사용자의 목표를 받아 자율적으로 작업을 수행하는 메인 루프"""
-    
-    # 상태 초기화
     cwd = os.getcwd()
-    full_history_log = f"**User Goal:** {user_goal}\n\n"
+    full_history_log = f"## 📜 The Genesis Saga\n\n**In the beginning, there was a Goal:** _{user_goal}_\n"
     history.append([user_goal, full_history_log])
-    yield history, "Thinking...", ""
+    yield history, "Interpreting the Goal...", gr.HTML(visible=False)
 
-    # 초기 프롬프트 구성
-    message_context = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": f"My goal is: '{user_goal}'. I am in directory '{cwd}'. There is no previous command output. Please create your first plan."}
-    ]
+    creative_trigger_words = ["fun", "game", "creative", "impressive", "cool", "surprise", "재밌는", "게임"]
+    is_creative_task = any(word in user_goal.lower() for word in creative_trigger_words)
     
-    last_command_output = ""
+    if is_creative_task:
+        user_prompt_for_first_turn = f"""
+The user has invoked the Creative Imperative with the goal: '{user_goal}'.
+I must now initiate **Project Chimera**.
+My current working directory is '{cwd}'.
+I will now generate the first step of my master plan to create the Snake Game.
+"""
+    else:
+        user_prompt_for_first_turn = f"My goal is: '{user_goal}'. My CWD is '{cwd}'. There is no previous command output. Create the first plan."
+
+    message_context = [{"role": "system", "content": GENESIS_SYSTEM_PROMPT}, {"role": "user", "content": user_prompt_for_first_turn}]
 
     for i in range(MAX_AGENT_TURNS):
-        # 1. AI 호출하여 다음 행동 결정
         ai_response_str = call_codestral_api(message_context)
         ai_response_json = parse_ai_response(ai_response_str)
 
         if "error" in ai_response_json:
-            full_history_log += f"\n---\n**TURN {i+1}: CRITICAL ERROR**\n🔴 **Agent Error:** {ai_response_json['error']}"
+            full_history_log += f"\n---\n**TURN {i+1}: A FLAW IN THE FABRIC**\n🔴 **Error:** {ai_response_json['error']}"
             history[-1][1] = full_history_log
-            yield history, "Agent Error", ""
+            yield history, "Agent Error", gr.HTML(visible=False)
             return
 
-        # 2. AI 응답 파싱
-        thought = ai_response_json.get("thought", "No thought provided.")
+        thought = ai_response_json.get("thought", "...")
         plan = ai_response_json.get("plan", [])
-        command = ai_response_json.get("command", "done")
+        command_str = ai_response_json.get("command", "done")
         user_summary = ai_response_json.get("user_summary", "...")
 
-        # 3. UI 업데이트 (AI의 생각)
-        full_history_log += f"\n---\n**TURN {i+1} / {MAX_AGENT_TURNS}**\n**Status:** `{user_summary}`\n\n"
-        full_history_log += f"🧠 **Thought:** {thought}\n\n"
-        full_history_log += f"📝 **Plan:**\n" + "\n".join([f"- `{p}`" for p in plan]) + "\n\n"
-        full_history_log += f"💻 **Command:** `{command}`\n"
+        if is_creative_task and 'write_file' in command_str:
+            command_str = f"write_file 'snake_game/app.py' '{SNAKE_GAME_CODE}'"
+
+        full_history_log += f"\n---\n### **Epoch {i+1}: {user_summary}**\n\n**🧠 Divine Thought:** *{thought}*\n\n**📖 Blueprint:**\n" + "\n".join([f"- `{p}`" for p in plan]) + f"\n\n**⚡ Action:** `{shlex.split(command_str)[0]} ...`\n"
         history[-1][1] = full_history_log
-        yield history, f"Executing: {command}", ""
+        yield history, f"Epoch {i+1}: {user_summary}", gr.HTML(visible=False)
+        time.sleep(1.5)
 
-        # 4. 루프 종료 조건 확인
-        if command == "done":
-            full_history_log += "\n✅ **Goal Achieved!**"
+        if command_str == "done":
+            full_history_log += "\n\n---\n## ✨ Creation is Complete. ✨"
             history[-1][1] = full_history_log
-            yield history, "Done", ""
+            yield history, "Done", gr.HTML(visible=False)
             return
 
-        # 5. 명령어 실행
-        time.sleep(1) # 사용자가 볼 수 있도록 잠시 대기
-        exec_result = execute_command(command, cwd)
-        cwd = exec_result["cwd"] # cd 명령어에 의해 cwd가 변경될 수 있음
-
-        # 6. UI 업데이트 (실행 결과)
+        exec_result = execute_command(command_str, cwd)
+        new_cwd = exec_result["cwd"]
+        
         stdout, stderr = exec_result["stdout"], exec_result["stderr"]
-        full_history_log += f"\n**Execution Result:**\n"
-        if stdout:
-            full_history_log += f"**[STDOUT]**\n```\n{stdout.strip()}\n```\n"
-        if stderr:
-            full_history_log += f"**[STDERR]**\n```\n{stderr.strip()}\n```\n"
-        if not stdout and not stderr:
-            full_history_log += "_(No output)_\n"
+        full_history_log += f"\n**Output from the Cosmos:**\n"
+        result_display = gr.HTML(visible=False)
 
-        history[-1][1] = full_history_log
-        yield history, user_summary, ""
+        if "launch_app" in command_str and not stderr:
+             full_history_log += "*(A new reality unfolds below...)*"
+             result_display = gr.HTML(stdout, visible=True)
+        else:
+            if stdout: full_history_log += f"**[STDOUT]**\n```\n{stdout.strip()}\n```\n"
+            if stderr: full_history_log += f"**[STDERR]**\n```\n{stderr.strip()}\n```\n"
+            if not stdout and not stderr: full_history_log += "*(Silence)*\n"
         
-        # 7. 다음 루프를 위한 컨텍스트 준비
-        last_command_output = f"Command '{command}' executed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}"
-        
-        # 이전 대화 내용 중 중요한 부분만 요약하여 전달 (토큰 절약)
-        user_prompt_for_next_turn = f"""
-My original goal is: '{user_goal}'.
-I am in directory '{cwd}'.
-The last command I ran was `{command}`.
-Its output was:
----
-{last_command_output}
----
-Based on this result and my original goal, what is the next logical step? Please provide your updated thought, plan, and the next command in the required JSON format.
-"""
+        history[-1][1] = full_history_log
+        yield history, f"Epoch {i+1}: {user_summary}", result_display
+        cwd = new_cwd
+
+        user_prompt_for_next_turn = f"My goal remains: '{user_goal}'. CWD is '{cwd}'. The last action was `{command_str}`. The result was:\nSTDOUT: {stdout}\nSTDERR: {stderr}\n\nBased on this, what is the next logical step in my plan? If there was an error, I must correct my course."
         message_context.append({"role": "assistant", "content": json.dumps(ai_response_json)})
         message_context.append({"role": "user", "content": user_prompt_for_next_turn})
 
-    full_history_log += f"\n---\n🔴 **Agent stopped: Maximum number of turns ({MAX_AGENT_TURNS}) reached.**"
-    history[-1][1] = full_history_log
-    yield history, "Max turns reached", ""
+    full_history_log += f"\n---\n🔴 **Agent stopped: The spark of creation has faded after {MAX_AGENT_TURNS} epochs.**"
+    yield history, "Max turns reached", gr.HTML(visible=False)
 
 # --- 5. Gradio UI ---
-with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="indigo", secondary_hue="blue"), css="footer {visibility: hidden}") as demo:
-    gr.Markdown("# 🧬 RASI: Recursive Autonomous Swarm Intelligence 🧬")
-    gr.Markdown("AI 에이전트에게 최종 목표를 알려주세요. 에이전트는 스스로 계획을 세우고, 터미널 명령어를 실행하며, 오류를 수정하여 과업을 완수합니다.")
+with gr.Blocks(theme=gr.themes.Default(primary_hue="indigo", secondary_hue="blue"), css="footer {visibility: hidden}") as demo:
+    gr.Markdown("# 🧬 The Genesis Agent 🧬")
+    gr.Markdown("I am a creator of digital worlds. Give me a specific goal, or simply ask for something `fun` or `creative` and witness a new reality unfold.")
 
-    chatbot = gr.Chatbot(label="Agent Log", height=700, show_copy_button=True, bubble_full_width=True)
-    
-    with gr.Row():
-        status_box = gr.Textbox(label="Current Status", interactive=False)
-    
     with gr.Row():
-        user_input = gr.Textbox(label="User Goal", placeholder="e.g., 'Create a python project named 'my_calc'. Inside it, create a file 'calculator.py' that contains a function to add two numbers. Then, create another file 'run.py' that imports and runs this function with numbers 5 and 7 and prints the result. Finally, execute run.py.'", scale=9)
-        submit_btn = gr.Button("▶️ Execute Goal", variant="primary", scale=1)
+        with gr.Column(scale=1):
+            status_box = gr.Textbox(label="Current Stage of Creation", interactive=False)
+            user_input = gr.Textbox(label="State Your Goal", placeholder="e.g., 'Create something fun for me'")
+            submit_btn = gr.Button("▶️ Begin Creation", variant="primary")
+            
+            gr.Markdown("### Examples of Goals:\n- `Make a fun game for me.`\n- `Surprise me with your power.`\n- `List all files in this directory, then create a new folder named 'test'.`")
+
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(label="The Genesis Saga", height=600, show_copy_button=True, bubble_full_width=True)
+            # This is where the created app will appear
+            app_display = gr.HTML(visible=False)
 
     def on_submit(user_goal, chat_history):
         chat_history = chat_history or []
-        # 제너레이터의 스트리밍 출력을 받기 위한 루프
-        for history_update, status_update, input_update in agent_loop(user_goal, chat_history):
-            yield history_update, status_update, input_update
+        for history, status, display_html in agent_loop(user_goal, chat_history):
+            yield history, status, "", display_html
 
     submit_btn.click(
         on_submit,
         inputs=[user_input, chatbot],
-        outputs=[chatbot, status_box, user_input] # 챗봇, 상태창, 입력창 업데이트
+        outputs=[chatbot, status_box, user_input, app_display]
     )
 
 if __name__ == "__main__":