Update app.py

app.py

@@ -4,6 +4,7 @@ import subprocess
 import requests
 import json
 import re
+import time
 
 # --- 1. 환경 설정 및 API 호출 함수 ---
 API_KEY = os.environ.get("MISTRAL_API_KEY")
@@ -17,24 +18,19 @@ def call_mistral_api(messages):
     if not API_KEY: return "Error: MISTRAL_API_KEY is not configured."
     data = {"model": "codestral-latest", "messages": messages}
     try:
-        response = requests.post(CODESTRAL_ENDPOINT, headers=HEADERS, data=json.dumps(data), timeout=30)
+        response = requests.post(CODESTRAL_ENDPOINT, headers=HEADERS, data=json.dumps(data), timeout=45)
         response.raise_for_status()
         return response.json()["choices"][0]["message"]["content"]
     except requests.exceptions.RequestException as e:
         return f"API Call Error: {e}"
 
-# --- 2. 백엔드 핵심 기능 함수 ---
+# --- 2. 백엔드 핵심 기능 (파서 포함) ---
 def parse_code_from_response(response_text: str) -> str | None:
-    """LLM 응답에서 C 코드 블록을 추출합니다."""
     match = re.search(r'```c\n(.*?)\n```', response_text, re.DOTALL)
     if match:
         return match.group(1).strip()
     return None
 
-def generate_c_code(description: str) -> str:
-    prompt = f"You are a C programming expert. Generate a complete, compilable C code for this request: '{description}'. ONLY output the raw C code, without any markdown formatting or explanations."
-    return call_mistral_api([{"role": "user", "content": prompt}])
-
 def compile_and_run_c_code(code: str) -> str:
     try:
         with open("main.c", "w", encoding='utf-8') as f: f.write(code)
@@ -46,55 +42,97 @@ def compile_and_run_c_code(code: str) -> str:
         return f"--- EXECUTION SUCCEEDED ---\n{output}" if output.strip() else "--- EXECUTION SUCCEEDED ---\n(No output was produced)"
     except Exception as e: return f"--- SYSTEM ERROR ---\nAn unexpected error occurred: {str(e)}"
 
-def analyze_and_refactor_code(code: str, instruction: str):
-    prompt = f""You are a senior C code reviewer. Fulfill this instruction: '{instruction}'. If you refactor the code, YOU MUST provide the complete, improved code in a ```c code block. \n\nC Code to Analyze:\n```c\n{code}\n```""
-    analysis_result = call_mistral_api([{"role": "user", "content": prompt}])
+# --- 3. 진짜 '지능형' 에이전트 로직 ---
+def intelligent_agent_ide(initial_code: str, full_instruction: str):
+    if not full_instruction:
+        yield initial_code, "Error: Instruction cannot be empty."
+        return
+
+    # 'and', 'then', ',' 등을 기준으로 명령어를 여러 단계로 분리
+    tasks = [task.strip() for task in re.split(r'\s+and\s+|\s*,\s*then\s*|\s*그리고\s*', full_instruction, flags=re.IGNORECASE)]
     
-    # 지능형 파싱: 리팩토링된 코드가 있는지 확인
-    refactored_code = parse_code_from_response(analysis_result)
+    current_code = initial_code
+    output_log = []
+    step = 1
+
+    for task in tasks:
+        lower_task = task.lower()
+        output_log.append(f"▶ Step {step}: Executing '{task}'...")
+        yield current_code, "\n".join(output_log)
+        time.sleep(0.5)
+
+        # 1. 생성 (Generation)
+        if "generate" in lower_task or "create" in lower_task or "만들어줘" in lower_task:
+            prompt = f"Generate a complete, compilable C code for this request: '{task}'. ONLY output the raw C code, without markdown or explanations."
+            new_code = call_mistral_api([{"role": "user", "content": prompt}])
+            current_code = new_code if new_code and "Error" not in new_code else current_code
+            output_log.append(f"✅ Code generated and updated in the editor.")
+            yield current_code, "\n".join(output_log)
+        
+        # 2. 컴파일 및 실행 (Compile & Run)
+        elif "compile" in lower_task or "run" in lower_task or "실행" in lower_task:
+            if not current_code:
+                output_log.append("❌ Error: Code is empty. Cannot compile.")
+                yield current_code, "\n".join(output_log)
+                break
+            result = compile_and_run_c_code(current_code)
+            output_log.append(result)
+            yield current_code, "\n".join(output_log)
+
+        # 3. 분석/리팩토링 (Analyze/Refactor)
+        else:
+            if not current_code:
+                output_log.append("❌ Error: Code is empty. Cannot analyze.")
+                yield current_code, "\n".join(output_log)
+                break
+            prompt = f"You are a senior C code reviewer. Fulfill this instruction: '{task}'. If you refactor or change the code, YOU MUST provide the complete, new code in a ```c code block. \n\nC Code to Analyze:\n```c\n{current_code}\n```"
+            analysis_result = call_mistral_api([{"role": "user", "content": prompt}])
+            
+            refactored_code = parse_code_from_response(analysis_result)
+            if refactored_code:
+                current_code = refactored_code
+                output_log.append(f"✅ Code refactored and updated in the editor.")
+            output_log.append(f"🔎 Analysis Result:\n{analysis_result}")
+            yield current_code, "\n".join(output_log)
+
+        step += 1
     
-    if refactored_code:
-        # 리팩토링된 코드가 있으면, 그 코드를 에디터에, 전체 응답을 결과창에 반환
-        return refactored_code, analysis_result
-    else:
-        # 리팩토링된 코드가 없으면, 원래 코드는 그대로 두고, 분석 결과만 반환
-        return code, analysis_result
-
-# --- 3. Gradio UI 구성 (안정적인 탭 구조 + 지능형 파싱) ---
+    output_log.append("\n--- All tasks complete. ---")
+    yield current_code, "\n".join(output_log)
+
+
+# --- 4. 통합된 Gradio UI ---
 with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="indigo", secondary_hue="blue"), css="footer {visibility: hidden}") as demo:
-    gr.Markdown("# 💻 The C-Codestral IDE Agent (Stable Tabbed Version)")
+    gr.Markdown("# 💻 The True C-Codestral IDE Agent")
 
     with gr.Tabs():
-        with gr.TabItem("👨‍💻 IDE"):
-            with gr.Row():
+        with gr.TabItem("👨‍💻 IDE Agent"):
+            with gr.Row(equal_height=True):
                 with gr.Column(scale=2):
-                    code_editor = gr.Code(label="C Code Editor", language="c", lines=20, interactive=True, value='#include <stdio.h>\n\nint main() {\n    printf("Hello, World!\\n");\n    return 0;\n}')
+                    code_editor = gr.Code(label="C Code Editor", language="c", lines=28, interactive=True, value='#include <stdio.h>\n\nint main() {\n    printf("Hello, World!\\n");\n    return 0;\n}')
                 
                 with gr.Column(scale=1):
-                    # 명령어 탭 구성
-                    with gr.Tabs():
-                        with gr.TabItem("Generate"):
-                            gen_instr = gr.Textbox(label="Generation Instruction", placeholder="e.g., 'a program that calculates factorial'")
-                            gen_btn = gr.Button("Generate Code", variant="primary")
-                        with gr.TabItem("Analyze / Refactor"):
-                            ana_instr = gr.Textbox(label="Analysis Instruction", placeholder="e.g., 'add comments', 'refactor for efficiency'")
-                            ana_btn = gr.Button("Analyze / Refactor", variant="primary")
-                        with gr.TabItem("Compile / Run"):
-                            run_btn = gr.Button("Compile and Run", variant="stop")
-
-            output_box = gr.Textbox(label="Output / Console", lines=8, interactive=False, show_copy_button=True)
-
-            # 이벤트 핸들러 연결
-            gen_btn.click(fn=generate_c_code, inputs=[gen_instr], outputs=[code_editor])
-            ana_btn.click(fn=analyze_and_refactor_code, inputs=[code_editor, ana_instr], outputs=[code_editor, output_box])
-            run_btn.click(fn=compile_and_run_c_code, inputs=[code_editor], outputs=[output_box])
-            
-        with gr.TabItem("🛠️ MCP Tools"):
-            gr.Markdown("## Available MCP Tools for other Agents")
+                    instruction_box = gr.Textbox(label="Instruction", placeholder="e.g., 'Refactor this code for readability, and then compile it'", lines=4)
+                    execute_btn = gr.Button("Execute", variant="primary", size="lg")
+                    output_box = gr.Textbox(label="Console / Output", lines=21, interactive=False, show_copy_button=True, max_lines=50)
+
+            execute_btn.click(
+                fn=intelligent_agent_ide, 
+                inputs=[code_editor, instruction_box], 
+                outputs=[code_editor, output_box]
+            )
+
+        with gr.TabItem("🛠️ MCP Tools API"):
+            gr.Markdown("## Available MCP Tools for other Agents\nThese APIs are the building blocks of our IDE agent.")
             with gr.Accordion("Tool: Generate C Code", open=False):
-                gr.Interface(fn=generate_c_code, inputs="text", outputs=gr.Code(language="c", label="Generated C Code"))
+                # MCP용 툴은 'generate_c_code' 함수를 직접 노출
+                prompt_input = gr.Textbox(label="Description")
+                code_output = gr.Code(language="c", label="Generated C Code")
+                gr.Interface(fn=generate_c_code, inputs=prompt_input, outputs=code_output)
             with gr.Accordion("Tool: Compile & Run C Code", open=False):
-                gr.Interface(fn=compile_and_run_c_code, inputs=gr.Code(language="c"), outputs=gr.Textbox(label="Output"))
+                code_input_run = gr.Code(language="c", label="C Code to Run")
+                text_output_run = gr.Textbox(label="Output")
+                gr.Interface(fn=compile_and_run_c_code, inputs=code_input_run, outputs=text_output_run)
 
 if __name__ == "__main__":
     demo.queue().launch()