Update app.py

app.py

@@ -6,104 +6,153 @@ import json
 import re
 import time
 
-# --- 1. 환경 설정 및 API 호출 함수 ---
-API_KEY = os.environ.get("MISTRAL_API_KEY")
+# --- 1. 환경 설정 및 강화된 API 호출 함수 ---
+# MISTRAL_API_KEY를 Space Secrets에 설정해야 합니다.
+MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
 CODESTRAL_ENDPOINT = "https://codestral.mistral.ai/v1/chat/completions"
-HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
 
-if not API_KEY:
-    print("FATAL: MISTRAL_API_KEY is not set in Space Secrets.")
-
-def call_mistral_api(messages):
-    if not API_KEY: return "Error: MISTRAL_API_KEY is not configured."
+# 시스템 프롬프트를 활용하기 위해 API 호출 함수 수정
+def call_mistral_api(system_prompt: str, user_prompt: str):
+    """향상된 Mistral API 호출 함수. 시스템 역할을 명시적으로 전달합니다."""
+    if not MISTRAL_API_KEY:
+        # UI에 직접 에러를 표시하는 것이 더 나은 사용자 경험을 제공합니다.
+        raise gr.Error("MISTRAL_API_KEY is not set. Please add it to your Space Secrets.")
+    
+    headers = {"Authorization": f"Bearer {MISTRAL_API_KEY}", "Content-Type": "application/json"}
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt}
+    ]
     data = {"model": "codestral-latest", "messages": messages}
+    
     try:
-        response = requests.post(CODESTRAL_ENDPOINT, headers=HEADERS, data=json.dumps(data), timeout=45)
+        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:
-    match = re.search(r'```c\n(.*?)\n```', response_text, re.DOTALL)
+    """
+    모델의 응답에서 C 코드 블록을 파싱합니다.
+    안정성을 위해 ```c 태그가 없는 경우에도 대비합니다.
+    """
+    match = re.search(r'```(?:c)?\n(.*?)\n```', response_text, re.DOTALL)
     if match:
         return match.group(1).strip()
+    # 만약 모델이 코드만 반환하는 경우에 대한 대비
+    elif response_text.strip().startswith("#include") and response_text.strip().endswith("}"):
+        return response_text.strip()
     return None
 
-# --- MCP 탭과 에이전트가 모두 사용할 전역 함수로 정의 ---
+# --- MCP 탭과 에이전트가 모두 사용할 전역 함수 (프롬프트 최적화) ---
 def generate_c_code(description: str) -> str:
-    prompt = f"Generate a complete, compilable C code for this request: '{description}'. ONLY output the raw C code, without markdown or explanations."
-    return call_mistral_api([{"role": "user", "content": prompt}])
+    system_prompt = "You are an expert C code generator. Your task is to generate complete, compilable C code based on the user's request. Output ONLY the raw C code within a ```c block, without any additional explanations."
+    user_prompt = f"Generate C code for the following request: '{description}'"
+    response = call_mistral_api(system_prompt, user_prompt)
+    return parse_code_from_response(response) or f"// Failed to parse code from response:\n{response}"
 
 def compile_and_run_c_code(code: str) -> str:
+    """C 코드를 컴파일하고 실행하는 함수. 오류 메시지를 더 명확하게 개선."""
+    if not code or not isinstance(code, str) or not code.strip():
+        return "--- SYSTEM ERROR ---\nCode is empty or invalid. Cannot process."
     try:
         with open("main.c", "w", encoding='utf-8') as f: f.write(code)
+        
+        # -lm(수학 라이브러리), -w(경고 무시) 옵션 추가
         compile_proc = subprocess.run(["gcc", "main.c", "-o", "main.out", "-lm", "-w"], capture_output=True, text=True, timeout=15)
-        if compile_proc.returncode != 0: return f"--- COMPILATION FAILED ---\n{compile_proc.stderr}"
+        if compile_proc.returncode != 0:
+            return f"--- COMPILATION FAILED ---\n{compile_proc.stderr}"
+            
         run_proc = subprocess.run(["./main.out"], capture_output=True, text=True, timeout=15)
-        if run_proc.returncode != 0: return f"--- RUNTIME ERROR ---\n{run_proc.stderr}"
+        if run_proc.returncode != 0:
+            return f"--- RUNTIME ERROR ---\n{run_proc.stderr}"
+            
         output = run_proc.stdout
         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)}"
-    
+    except Exception as e:
+        return f"--- SYSTEM ERROR ---\nAn unexpected error occurred: {str(e)}"
+
 def analyze_and_refactor_code(code: str, instruction: str) -> str:
-    prompt = f"You are a senior C code reviewer. Fulfill this instruction: '{instruction}'. 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{code}\n```"
-    return call_mistral_api([{"role": "user", "content": prompt}])
+    system_prompt = "You are a world-class C code reviewer and refactoring expert. Analyze the user-provided C code based on their instruction. If you refactor or change the code, YOU MUST provide the complete, new C code in a ```c block. Otherwise, provide your analysis as plain text."
+    user_prompt = f"Instruction: '{instruction}'\n\nC Code to Analyze:\n```c\n{code}\n```"
+    return call_mistral_api(system_prompt, user_prompt)
 
-# --- 3. 진짜 '지능형' 에이전트 로직 ---
+# --- 3. 진짜 '지능형' 에이전트 로직 (개선된 버전) ---
 def intelligent_agent_ide(initial_code: str, full_instruction: str):
-    if not full_instruction:
-        yield initial_code, "Error: Instruction cannot be empty."
+    if not full_instruction.strip():
+        yield initial_code, "❌ Error: Instruction cannot be empty."
         return
 
-    tasks = [task.strip() for task in re.split(r'\s+and\s+|\s*,\s*then\s*|\s*그리고\s*', full_instruction, flags=re.IGNORECASE)]
+    # 더 정확한 작업 분리를 위해 정규표현식 개선
+    tasks = [task.strip() for task in re.split(r'\s+and then\s+|\s+and\s+|,\s*then\s*|\s*그리고\s+|\s*후에\s*', full_instruction, flags=re.IGNORECASE) if task.strip()]
     
     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)
+    # ⭐️ Step 1: 실행 계획 수립 및 제시
+    plan_log = ["📝 Agent's Plan:"]
+    for i, task in enumerate(tasks):
+        plan_log.append(f"{i+1}. {task}")
+    output_log.extend(plan_log)
+    yield current_code, "\n".join(output_log)
+    time.sleep(1)
 
-        if "generate" in lower_task or "create" in lower_task or "만들어줘" in lower_task:
-            new_code = generate_c_code(task)
-            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)
+    # ⭐️ Step 2: 계획에 따라 작업 순차 실행
+    for i, task in enumerate(tasks):
+        lower_task = task.lower()
         
+        # ⭐️ 에이전트의 '생각' 과정을 명시적으로 보여줌
+        thought = ""
+        action_func = None
+        action_arg = task
+
+        if "generate" in lower_task or "create" in lower_task or "만들어" in lower_task or "작성" in lower_task:
+            thought = f"The user wants to generate new code. Using 'generate_c_code' tool."
+            action_func = generate_c_code
         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)
+            thought = f"The user wants to compile and run the code. Using 'compile_and_run_c_code' tool."
+            action_func = compile_and_run_c_code
+            action_arg = current_code # 실행은 현재 코드를 인자로 받음
+        else: # 그 외 모든 경우는 분석/리팩토링으로 간주
+            thought = f"The user wants to analyze or refactor the code. Using 'analyze_and_refactor_code' tool."
+            action_func = analyze_and_refactor_code
+            action_arg = (current_code, task) # 분석은 코드와 지시를 인자로 받음
+
+        output_log.append(f"\n▶ Step {i+1}: {task}\n🧠 Thought: {thought}")
+        yield current_code, "\n".join(output_log)
+        time.sleep(1)
 
+        # 액션 실행
+        if isinstance(action_arg, tuple):
+            result = action_func(*action_arg)
         else:
-            if not current_code:
-                output_log.append("❌ Error: Code is empty. Cannot analyze.")
-                yield current_code, "\n".join(output_log)
-                break
-            analysis_result = analyze_and_refactor_code(current_code, task)
-            
-            refactored_code = parse_code_from_response(analysis_result)
+            result = action_func(action_arg)
+
+        # 결과 처리
+        if action_func == generate_c_code:
+            if result and not result.startswith("//"):
+                current_code = result
+                output_log.append("✅ Code generated and updated in the editor.")
+            else:
+                output_log.append(f"❌ Generation failed: {result}")
+        elif action_func == compile_and_run_c_code:
+            output_log.append(f"💻 Result:\n{result}")
+        elif action_func == analyze_and_refactor_code:
+            refactored_code = parse_code_from_response(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)
+                output_log.append("✅ Code refactored and updated in the editor.")
+            output_log.append(f"🔎 Analysis Result:\n{result}")
+        
+        yield current_code, "\n".join(output_log)
 
-        step += 1
-    
-    output_log.append("\n--- All tasks complete. ---")
+    output_log.append("\n\n--- All tasks complete. ---")
     yield current_code, "\n".join(output_log)
 
-# --- 4. 통합된 Gradio UI ---
+
+# --- 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 True C-Codestral IDE Agent")
 
@@ -131,7 +180,11 @@ with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="indigo", secondary_hue="b
             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"))
             with gr.Accordion("Tool: Analyze & Refactor C Code", open=False):
-                gr.Interface(fn=analyze_and_refactor_code, inputs=[gr.Code(language="c"), "text"], outputs=gr.Markdown())
+                gr.Interface(fn=analyze_and_refactor_code, inputs=[gr.Code(language="c", label="Code to Analyze"), gr.Textbox(label="Instruction")], outputs=gr.Markdown())
 
 if __name__ == "__main__":
+    if not MISTRAL_API_KEY:
+        print("WARNING: MISTRAL_API_KEY is not set. The application will not work correctly.")
+        # 로컬 실행 시에는 키가 없어도 UI는 띄울 수 있도록 처리
+        # demo.launch()가 실패하지 않도록 API 키 확인은 함수 내부에서 gr.Error로 처리
     demo.queue().launch()