Update app.py

app.py

@@ -1,27 +1,18 @@
 import gradio as gr
-from huggingface_hub import HfApi, create_repo
-from git import Repo
+from huggingface_hub import HfApi
 import uuid 
 from slugify import slugify
 import os
-import sys
 import json
-import argparse
 import subprocess
 import tempfile
-import textwrap
 import requests
 import shutil
 import time
 from pathlib import Path
-from typing import Optional, Dict, List, Tuple
+from typing import Optional, Dict, List
 
-# ========== LFS 처리 함수 (첫 번째 코드에서) ========== #
 def is_lfs_pointer_file(filepath):
-    """Check if a file is a Git LFS pointer file."""
-    # Initialize analysis
-    analysis = {}
-    
     try:
         with open(filepath, 'rb') as f:
             header = f.read(100)
@@ -30,66 +21,50 @@ def is_lfs_pointer_file(filepath):
         return False
 
 def remove_lfs_files(folder):
-    """Remove all LFS pointer files from the repository."""
     removed_files = []
     for root, dirs, files in os.walk(folder):
-        # Skip .git directory
         if '.git' in root:
             continue
-            
         for file in files:
             filepath = os.path.join(root, file)
             if is_lfs_pointer_file(filepath):
                 os.remove(filepath)
                 removed_files.append(filepath.replace(folder + os.sep, ''))
-    
     return removed_files
 
-# ========== Repository 분석 함수 (두 번째 코드에서) ========== #
 def analyze_repository(src_path: Path) -> Dict:
-    """레포지토리 구조와 내용을 분석하여 정보 추출"""
     analysis = {
         "has_requirements": False,
         "has_readme": False,
-        "has_setup_py": False,
         "main_language": "python",
         "key_files": [],
         "dependencies": [],
         "description": "",
-        "installation_steps": [],
-        "usage_examples": [],
+        "entry_points": [],
         "model_files": [],
-        "data_files": [],
-        "config_files": [],
-        "entry_points": []
+        "config_files": []
     }
     
-    # requirements.txt 분석
     req_file = src_path / "requirements.txt"
     if req_file.exists():
         analysis["has_requirements"] = True
         try:
             reqs = req_file.read_text(encoding="utf-8").strip().split("\n")
-            # 의존성 필터링 및 정리
             cleaned_deps = []
             for r in reqs:
                 r = r.strip()
                 if r and not r.startswith("#"):
-                    # 잘못된 버전 수정
                     if "opencv-python==4.10.0" in r:
                         r = "opencv-python>=4.10.0.82"
                     elif "opencv-python==4.10" in r:
                         r = "opencv-python>=4.10.0.82"
                     
-                    # 버전 제약이 너무 엄격한 경우 완화
                     if "==" in r and not r.startswith("git+"):
                         pkg_name = r.split("==")[0]
-                        # 중요한 패키지는 버전 유지, 나머지는 >= 로 변경
                         if pkg_name.lower() in ["torch", "tensorflow", "transformers", "numpy"]:
                             cleaned_deps.append(r)
                         else:
                             version = r.split("==")[1]
-                            # 버전이 x.y 형식이면 x.y.0으로 변경
                             if version.count('.') == 1:
                                 version = version + ".0"
                             cleaned_deps.append(f"{pkg_name}>={version}")
@@ -99,62 +74,34 @@ def analyze_repository(src_path: Path) -> Dict:
         except:
             analysis["dependencies"] = []
     
-    # README 분석
     for readme_name in ["README.md", "readme.md", "README.rst", "README.txt"]:
         readme_file = src_path / readme_name
         if readme_file.exists():
             analysis["has_readme"] = True
             try:
                 readme_content = readme_file.read_text(encoding="utf-8")
-                analysis["readme_content"] = readme_content[:5000]  # 처음 5000자만
-                
-                # 설명 추출
+                analysis["readme_content"] = readme_content[:5000]
                 lines = readme_content.split("\n")
                 for i, line in enumerate(lines[:10]):
                     if line.strip() and not line.startswith("#") and not line.startswith("!"):
                         analysis["description"] = line.strip()
                         break
-                
-                # 설치 방법 찾기
-                install_section = False
-                usage_section = False
-                for line in lines:
-                    if "install" in line.lower() and "#" in line:
-                        install_section = True
-                        usage_section = False
-                        continue
-                    elif "usage" in line.lower() and "#" in line:
-                        usage_section = True
-                        install_section = False
-                        continue
-                    elif "#" in line:
-                        install_section = False
-                        usage_section = False
-                    
-                    if install_section and line.strip():
-                        analysis["installation_steps"].append(line.strip())
-                    elif usage_section and line.strip():
-                        analysis["usage_examples"].append(line.strip())
             except:
                 pass
     
-    # 주요 Python 파일 찾기
     py_files = list(src_path.glob("**/*.py"))
-    for py_file in py_files[:20]:  # 최대 20개만 분석
+    for py_file in py_files[:20]:
         if "__pycache__" not in str(py_file) and ".git" not in str(py_file):
             relative_path = py_file.relative_to(src_path)
             
-            # 엔트리 포인트 후보 찾기
             if any(name in py_file.name for name in ["main.py", "app.py", "demo.py", "run.py", "server.py", "streamlit_app.py"]):
                 analysis["entry_points"].append(str(relative_path))
             
-            # 파일 내용 간단히 확인
             try:
                 content = py_file.read_text(encoding="utf-8")[:1000]
                 if "if __name__" in content and "main" in content:
                     analysis["entry_points"].append(str(relative_path))
                 
-                # 주요 import 확인
                 if any(lib in content for lib in ["torch", "tensorflow", "transformers", "numpy", "pandas", "cv2", "PIL"]):
                     analysis["key_files"].append({
                         "path": str(relative_path),
@@ -163,7 +110,6 @@ def analyze_repository(src_path: Path) -> Dict:
             except:
                 pass
     
-    # 모델 파일 찾기
     model_extensions = [".pth", ".pt", ".ckpt", ".h5", ".pb", ".onnx", ".safetensors"]
     for ext in model_extensions:
         model_files = list(src_path.glob(f"**/*{ext}"))
@@ -171,7 +117,6 @@ def analyze_repository(src_path: Path) -> Dict:
             if ".git" not in str(mf):
                 analysis["model_files"].append(str(mf.relative_to(src_path)))
     
-    # 설정 파일 찾기
     config_patterns = ["config.json", "config.yaml", "config.yml", "*.json", "*.yaml"]
     for pattern in config_patterns:
         config_files = list(src_path.glob(pattern))
@@ -181,63 +126,7 @@ def analyze_repository(src_path: Path) -> Dict:
     
     return analysis
 
-# ========== Brave Search 헬퍼 (두 번째 코드에서) ========== #
-def search_repo_info(repo_url: str) -> str:
-    """Brave Search로 레포지토리 정보 수집"""
-    api_key = os.getenv("BAPI_TOKEN")
-    if not api_key:
-        return ""
-    
-    api_key = api_key.strip()
-    headers = {"X-Subscription-Token": api_key, "Accept": "application/json"}
-    
-    # 레포지토리 이름 추출
-    repo_parts = repo_url.rstrip("/").split("/")
-    if len(repo_parts) >= 2:
-        repo_name = f"{repo_parts[-2]}/{repo_parts[-1]}"
-    else:
-        return ""
-    
-    # 검색 쿼리들
-    queries = [
-        f'"{repo_name}" github tutorial',
-        f'"{repo_name}" usage example',
-        f'"{repo_name}" gradio streamlit demo'
-    ]
-    
-    search_results = []
-    for query in queries:
-        params = {"q": query, "count": 3}
-        try:
-            resp = requests.get(
-                "https://api.search.brave.com/res/v1/web/search",
-                headers=headers, 
-                params=params, 
-                timeout=10
-            )
-            if resp.status_code == 200:
-                results = resp.json().get("web", {}).get("results", [])
-                for r in results:
-                    search_results.append({
-                        "title": r.get("title", ""),
-                        "description": r.get("description", ""),
-                        "url": r.get("url", "")
-                    })
-        except:
-            continue
-    
-    # 검색 결과를 텍스트로 변환
-    search_text = f"Search results for {repo_name}:\n"
-    for r in search_results[:5]:
-        search_text += f"\n- {r['title']}: {r['description']}\n"
-    
-    return search_text
-
-# ========== AI 생성 헬퍼 (두 번째 코드에서) ========== #
-def generate_gradio_app(repo_url: str, analysis: Dict, search_info: str = "") -> Dict:
-    """AI로 실제 동작하는 Gradio 앱 생성"""
-    
-    # 컨텍스트 준비
+def generate_gradio_app(repo_url: str, analysis: Dict) -> Dict:
     context = f"""Repository URL: {repo_url}
 
 Repository Analysis:
@@ -256,22 +145,6 @@ Key Files Found:
     if analysis.get('readme_content'):
         context += f"\n--- README.md (excerpt) ---\n{analysis['readme_content'][:2000]}\n"
     
-    if search_info:
-        context += f"\n--- Web Search Results ---\n{search_info}\n"
-    
-    # Installation steps
-    if analysis['installation_steps']:
-        context += f"\nInstallation Steps:\n"
-        for step in analysis['installation_steps'][:5]:
-            context += f"- {step}\n"
-    
-    # Usage examples
-    if analysis['usage_examples']:
-        context += f"\nUsage Examples:\n"
-        for ex in analysis['usage_examples'][:5]:
-            context += f"- {ex}\n"
-    
-    # System prompt
     system_prompt = """You are an expert at creating Gradio apps from GitHub repositories. 
 Your task is to generate a complete, working Gradio interface that demonstrates the main functionality of the repository.
 
@@ -281,50 +154,43 @@ CRITICAL REQUIREMENTS:
 3. Handle errors gracefully with clear user feedback
 4. Include API key inputs when external services are required
 5. Create intuitive UI components for the main features
-6. Include helpful descriptions and examples
-7. Always use gradio>=5.35.0
-8. If the project requires external APIs (OpenAI, Anthropic, etc), include:
-   - API key input fields
-   - Clear instructions on how to obtain keys
-   - Environment variable setup guidance
-   - Graceful handling when keys are missing
+6. Always use gradio>=5.35.0
 
 Return ONLY valid JSON with these exact keys:
 - app_py: Complete Gradio app code
 - requirements_txt: All necessary dependencies including gradio>=5.35.0
 - summary: Brief description of what the app does"""
     
-    # OpenAI 시도
-    openai_key = os.getenv("OPENAI_API_KEY")
-    if openai_key:
+    # Fireworks AI API 시도
+    fireworks_key = os.getenv("FIREWORKS_API_KEY")
+    if fireworks_key:
         try:
-            headers = {
-                "Authorization": f"Bearer {openai_key.strip()}",
-                "Content-Type": "application/json"
-            }
-            
+            url = "https://api.fireworks.ai/inference/v1/chat/completions"
             payload = {
-                "model": "gpt-4o-mini",
+                "model": "accounts/fireworks/models/qwen3-coder-480b-a35b-instruct",
+                "max_tokens": 4096,
+                "top_p": 1,
+                "top_k": 40,
+                "presence_penalty": 0,
+                "frequency_penalty": 0,
+                "temperature": 0.6,
                 "messages": [
                     {"role": "system", "content": system_prompt},
                     {"role": "user", "content": f"Create a fully functional Gradio app for this repository:\n\n{context[:8000]}"}
-                ],
-                "temperature": 0.3,
-                "max_tokens": 4000
+                ]
+            }
+            headers = {
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {fireworks_key.strip()}"
             }
             
-            r = requests.post(
-                "https://api.openai.com/v1/chat/completions",
-                json=payload,
-                headers=headers,
-                timeout=30
-            )
+            r = requests.post(url, headers=headers, data=json.dumps(payload), timeout=30)
             
             if r.status_code == 200:
                 response_text = r.json()["choices"][0]["message"]["content"]
-                print("✅ OpenAI API로 스마트 앱 생성 성공")
+                print("✅ Fireworks AI로 앱 생성 성공")
                 
-                # JSON 파싱
                 try:
                     if "```json" in response_text:
                         start = response_text.find("```json") + 7
@@ -349,76 +215,25 @@ Return ONLY valid JSON with these exact keys:
                     print(f"⚠️ JSON 파싱 오류: {e}")
                     return None
         except Exception as e:
-            print(f"⚠️ OpenAI API 오류: {e}")
+            print(f"⚠️ Fireworks AI API 오류: {e}")
     
-    # Friendli 시도
-    friendli_token = os.getenv("FRIENDLI_TOKEN")
-    if friendli_token:
-        try:
-            headers = {
-                "Authorization": f"Bearer {friendli_token.strip()}",
-                "Content-Type": "application/json"
-            }
-            
-            payload = {
-                "model": "meta-llama-3.1-70b-instruct",
-                "messages": [
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": f"Create a Gradio app:\n{context[:6000]}"}
-                ],
-                "max_tokens": 4000,
-                "temperature": 0.3
-            }
-            
-            for endpoint in [
-                "https://api.friendli.ai/v1/chat/completions",
-                "https://api.friendli.ai/dedicated/v1/chat/completions"
-            ]:
-                r = requests.post(endpoint, json=payload, headers=headers, timeout=30)
-                if r.status_code == 200:
-                    response_text = r.json()["choices"][0]["message"]["content"]
-                    print("✅ Friendli API로 스마트 앱 생성 성공")
-                    
-                    if "```json" in response_text:
-                        start = response_text.find("```json") + 7
-                        end = response_text.find("```", start)
-                        response_text = response_text[start:end].strip()
-                    
-                    result = json.loads(response_text)
-                    
-                    if "gradio" not in result.get("requirements_txt", "").lower():
-                        result["requirements_txt"] = "gradio>=5.35.0\n" + result.get("requirements_txt", "")
-                    
-                    return result
-        except Exception as e:
-            print(f"⚠️ Friendli API 오류: {e}")
-    
-    # 스마트 기본 템플릿 생성
-    print("ℹ️ AI API가 없어 스마트 기본 템플릿을 생성합니다.")
+    print("ℹ️ AI API가 없어 기본 템플릿을 생성합니다.")
     return create_smart_template(repo_url, analysis)
 
 def create_smart_template(repo_url: str, analysis: Dict) -> Dict:
-    """분석 결과를 바탕으로 스마트한 기본 템플릿 생성"""
-    
     repo_name = Path(repo_url.rstrip("/")).name
     description = analysis.get("description", "A project deployed from GitHub") if analysis else "A project deployed from GitHub"
     
-    # 의존성 기반 앱 타입 결정
     deps = " ".join(analysis.get("dependencies", [])) if analysis else ""
-    has_ml = any(lib in deps for lib in ["torch", "tensorflow", "transformers", "scikit-learn"])
     has_cv = any(lib in deps for lib in ["cv2", "PIL", "pillow", "opencv"])
     has_nlp = any(lib in deps for lib in ["transformers", "nltk", "spacy"])
-    has_audio = any(lib in deps for lib in ["librosa", "soundfile", "pyaudio"])
     has_3d = any(lib in deps for lib in ["gaussian", "rasterizer", "plyfile", "trimesh"])
     
-    # 기본 requirements - git 의존성 제외
     requirements = ["gradio>=5.35.0"]
     if analysis and analysis.get("dependencies"):
-        # git+ 의존성과 로컬 의존성 제외
         filtered_deps = []
         for dep in analysis["dependencies"][:15]:
             if not dep.startswith("git+") and not dep.startswith("-e") and not dep.startswith("file:"):
-                # 버전이 너무 엄격한 경우 완화
                 if "==" in dep and dep.split("==")[0].lower() not in ["torch", "tensorflow", "numpy"]:
                     pkg_name = dep.split("==")[0]
                     version = dep.split("==")[1]
@@ -427,21 +242,11 @@ def create_smart_template(repo_url: str, analysis: Dict) -> Dict:
                     filtered_deps.append(dep)
         requirements.extend(filtered_deps)
     
-    # 앱 타입별 템플릿 생성
     if has_3d or "gaussian" in repo_name.lower():
-        # 3D/Gaussian Splatting 앱
         app_code = f'''import gradio as gr
 import os
-import sys
-
-# Repository: {repo_url}
-# {description}
-
-# Note: This project requires CUDA-enabled GPU and complex build dependencies
-# The original repository uses custom CUDA extensions that need compilation
 
 def process_3d(input_file):
-    """3D processing function - placeholder for actual implementation"""
     if input_file is None:
         return "Please upload a 3D file or image"
     
@@ -451,21 +256,11 @@ def process_3d(input_file):
     This project requires:
     1. CUDA-enabled GPU
     2. Custom C++/CUDA extensions compilation
-    3. Specific versions of PyTorch with CUDA support
-    
-    The git dependencies in requirements.txt need PyTorch to be installed first.
-    
-    For full functionality:
-    1. Install PyTorch with CUDA: `pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118`
-    2. Install build tools: `apt-get install build-essential python3-dev ninja-build`
-    3. Then install other requirements
     
     Original repository: {repo_url}
     """
-    
     return info
 
-# Gradio interface
 with gr.Blocks(title="{repo_name}") as demo:
     gr.Markdown(f"""
     # {repo_name.replace("-", " ").title()}
@@ -473,8 +268,6 @@ with gr.Blocks(title="{repo_name}") as demo:
     {description}
     
     This space was created from: [{repo_url}]({repo_url})
-    
-    **Note**: This project has complex build requirements. See below for details.
     """)
     
     with gr.Row():
@@ -499,25 +292,16 @@ if __name__ == "__main__":
 from PIL import Image
 import numpy as np
 
-# Repository: {repo_url}
-# {description}
-
 def process_image(image):
-    """이미지 처리 함수 - 실제 구현으로 교체 필요"""
     if image is None:
         return None, "Please upload an image"
     
-    # 여기에 실제 이미지 처리 로직 구현
-    # 예: 모델 로드, 전처리, 추론, 후처리
-    
-    # 데모용 간단한 처리
     img_array = np.array(image)
     processed = Image.fromarray(img_array)
     
-    info = f"Image shape: {img_array.shape}"
+    info = f"Image shape: {{img_array.shape}}"
     return processed, info
 
-# Gradio 인터페이스 생성
 with gr.Blocks(title="{repo_name}") as demo:
     gr.Markdown(f"""
     # {repo_name.replace("-", " ").title()}
@@ -549,30 +333,22 @@ if __name__ == "__main__":
     elif has_nlp:
         app_code = f'''import gradio as gr
 
-# Repository: {repo_url}
-# {description}
-
 def process_text(text, max_length=100):
-    """텍스트 처리 함수 - 실제 구현으로 교체 필요"""
     if not text:
         return "Please enter some text"
     
-    # 여기에 실제 NLP 처리 로직 구현
-    
-    # 데모용 간단한 처리
     word_count = len(text.split())
     char_count = len(text)
     
     result = f"""
     **Analysis Results:**
-    - Word count: {word_count}
-    - Character count: {char_count}
-    - Average word length: {char_count/max(word_count, 1):.1f}
+    - Word count: {{word_count}}
+    - Character count: {{char_count}}
+    - Average word length: {{char_count/max(word_count, 1):.1f}}
     """
     
     return result
 
-# Gradio 인터페이스 생성
 with gr.Blocks(title="{repo_name}") as demo:
     gr.Markdown(f"""
     # {repo_name.replace("-", " ").title()}
@@ -613,20 +389,13 @@ if __name__ == "__main__":
     else:
         app_code = f'''import gradio as gr
 
-# Repository: {repo_url}
-# {description}
-
 def main_function(input_data):
-    """메인 처리 함수 - 실제 구현으로 교체 필요"""
     if not input_data:
         return "Please provide input"
     
-    # 여기에 실제 처리 로직 구현
-    
-    result = f"Processed successfully! Input received: {input_data}"
+    result = f"Processed successfully! Input received: {{input_data}}"
     return result
 
-# Gradio 인터페이스 생성
 with gr.Blocks(title="{repo_name}") as demo:
     gr.Markdown(f"""
     # {repo_name.replace("-", " ").title()}
@@ -664,22 +433,17 @@ if __name__ == "__main__":
         "summary": f"Smart template created for {repo_name}"
     }
 
-# ========== 통합된 메인 clone 함수 ========== #
 def clone(repo_git, repo_hf, sdk_type, skip_lfs, enable_smart_generation):
-    """GitHub 레포지토리를 HuggingFace Space로 복제하고 스마트하게 app.py 생성"""
     folder = str(uuid.uuid4())
     
-    # 환경변수에서 HF_TOKEN 가져오기
     hf_token = os.getenv("HF_TOKEN")
     if not hf_token:
-        yield "❌ Error: HF_TOKEN not found in environment variables. Please set it in the Space settings."
+        yield "❌ Error: HF_TOKEN not found in environment variables."
         return
     
     try:
-        # Initialize progress messages
         yield "🔄 Starting clone process..."
         
-        # Get user info
         api = HfApi(token=hf_token)
         try:
             user_info = api.whoami()
@@ -689,65 +453,47 @@ def clone(repo_git, repo_hf, sdk_type, skip_lfs, enable_smart_generation):
             yield f"❌ Authentication failed: {str(e)}"
             return
         
-        # Clone the repository
         yield f"📥 Cloning repository from {repo_git}..."
         
         env = os.environ.copy()
-        
-        # Always skip LFS download initially to avoid errors
         env['GIT_LFS_SKIP_SMUDGE'] = '1'
         clone_cmd = ['git', 'clone', '--recurse-submodules', repo_git, folder]
         subprocess.run(clone_cmd, check=True, env=env)
         
         if not skip_lfs:
-            # Try to pull LFS files
             yield "📦 Attempting to download LFS files..."
             try:
                 subprocess.run(['git', 'lfs', 'install'], cwd=folder, check=True)
                 lfs_result = subprocess.run(['git', 'lfs', 'pull'], cwd=folder, capture_output=True, text=True)
                 
                 if lfs_result.returncode != 0:
-                    yield f"⚠️ Warning: LFS download failed: {lfs_result.stderr}"
-                    yield "⚠️ Will remove LFS pointer files to prevent upload errors..."
-                    skip_lfs = True  # Force LFS skip
+                    yield f"⚠️ Warning: LFS download failed"
+                    skip_lfs = True
                 else:
                     yield "✅ LFS files downloaded successfully"
             except Exception as e:
                 yield f"⚠️ LFS error: {str(e)}"
-                yield "⚠️ Will remove LFS pointer files to prevent upload errors..."
-                skip_lfs = True  # Force LFS skip
+                skip_lfs = True
         
-        # If we're skipping LFS, remove all LFS pointer files
         if skip_lfs:
             yield "🧹 Removing LFS pointer files..."
             removed_files = remove_lfs_files(folder)
             if removed_files:
                 yield f"📝 Removed {len(removed_files)} LFS pointer files"
-                # Show first few removed files
-                for file in removed_files[:5]:
-                    yield f"  - {file}"
-                if len(removed_files) > 5:
-                    yield f"  ... and {len(removed_files) - 5} more files"
         
-        # 스마트 생성이 활성화된 경우
         if enable_smart_generation:
             yield "🔍 Analyzing repository structure..."
             folder_path = Path(folder)
             analysis = analyze_repository(folder_path)
             
-            yield "🔍 Searching for additional information..."
-            search_info = search_repo_info(repo_git)
-            
             yield "🤖 Generating smart Gradio app..."
-            generated = generate_gradio_app(repo_git, analysis, search_info)
+            generated = generate_gradio_app(repo_git, analysis)
             
             if generated and isinstance(generated, dict) and "app_py" in generated:
-                # app.py 생성/덮어쓰기
                 app_path = folder_path / "app.py"
                 app_path.write_text(generated["app_py"], encoding="utf-8")
                 yield "✅ Smart app.py generated"
                 
-                # requirements.txt 업데이트 - 의존성 순서 최적화
                 req_path = folder_path / "requirements.txt"
                 existing_reqs = []
                 if req_path.exists():
@@ -758,7 +504,6 @@ def clone(repo_git, repo_hf, sdk_type, skip_lfs, enable_smart_generation):
                 
                 new_reqs = generated["requirements_txt"].strip().split("\n") if generated["requirements_txt"] else []
                 
-                # 의존성 정리 및 순서 최적화
                 all_reqs = set()
                 git_reqs = []
                 torch_reqs = []
@@ -769,42 +514,33 @@ def clone(repo_git, repo_hf, sdk_type, skip_lfs, enable_smart_generation):
                     if not req or req.startswith("#"):
                         continue
                     
-                    # git+ 의존성은 따로 관리
                     if req.startswith("git+"):
                         git_reqs.append(req)
-                    # torch 관련 의존성은 먼저 설치
                     elif "torch" in req.lower() or "cuda" in req.lower():
                         torch_reqs.append(req)
                     else:
                         regular_reqs.append(req)
                 
-                # gradio 버전 확인 및 추가
                 has_gradio = any("gradio" in req for req in regular_reqs)
                 if not has_gradio:
                     regular_reqs.append("gradio>=5.35.0")
                 
-                # 최종 requirements.txt 생성 (순서 중요)
                 final_reqs = []
                 
-                # 1. torch 관련 먼저
                 if torch_reqs:
                     final_reqs.extend(sorted(set(torch_reqs)))
-                    final_reqs.append("")  # 빈 줄
+                    final_reqs.append("")
                 
-                # 2. 일반 의존성
                 final_reqs.extend(sorted(set(regular_reqs)))
                 
-                # 3. git 의존성은 마지막에 (torch가 필요한 경우가 많음)
                 if git_reqs:
-                    final_reqs.append("")  # 빈 줄
-                    final_reqs.append("# Git dependencies (installed last)")
+                    final_reqs.append("")
                     final_reqs.extend(sorted(set(git_reqs)))
                 
                 req_content = "\n".join(final_reqs)
                 req_path.write_text(req_content, encoding="utf-8")
-                yield "✅ Requirements.txt updated with optimized dependency order"
+                yield "✅ Requirements.txt updated"
                 
-                # README.md 업데이트 - 항상 생성하여 올바른 형식 보장
                 readme_path = folder_path / "README.md"
                 readme_content = f"""---
 title: {repo_hf.replace("-", " ").title()}
@@ -822,329 +558,17 @@ pinned: false
 {analysis.get('description', 'Deployed from GitHub repository')}
 
 Deployed from: {repo_git}
-
-## Features
-This Space provides a Gradio interface for the repository's main functionality.
-The app.py was automatically generated based on repository analysis.
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
 """
                 readme_path.write_text(readme_content, encoding="utf-8")
                 yield "✅ README.md created/updated"
-        else:
-            # 스마트 생성이 비활성화된 경우에도 README.md 확인 및 생성
-            readme_path = Path(folder) / "README.md"
-            if not readme_path.exists():
-                # 기본 README.md 생성
-                readme_content = f"""---
-title: {repo_hf.replace("-", " ").title()}
-emoji: 🚀
-colorFrom: blue
-colorTo: green
-sdk: {sdk_type}
-sdk_version: "5.35.0"
-app_file: app.py
-pinned: false
----
-
-# {repo_hf.replace("-", " ").title()}
-
-Deployed from: {repo_git}
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-"""
-                readme_path.write_text(readme_content, encoding="utf-8")
-                yield "✅ README.md created with required configuration"
-        
-        # requirements.txt 확인 및 문제 해결
-        req_path = Path(folder) / "requirements.txt"
-        if req_path.exists():
-            try:
-                req_content = req_path.read_text(encoding="utf-8")
-                lines = req_content.strip().split("\n")
-                
-                # 의존성 분류 및 중복 제거
-                torch_deps = []
-                git_deps = []
-                regular_deps = []
-                problem_git_deps = []  # torch가 필요한 git 의존성
-                seen_packages = {}  # 패키지명 -> 전체 의존성 매핑
-                
-                for line in lines:
-                    line = line.strip()
-                    if not line or line.startswith("#"):
-                        continue
-                    
-                    if line.startswith("git+"):
-                        # git 의존성 중 CUDA/컴파일이 필요한 경우 확인
-                        cuda_keywords = ["gaussian", "rasterizer", "diff-", "cuda", "nvdiffrast", "tiny-cuda"]
-                        if any(keyword in line.lower() for keyword in cuda_keywords):
-                            problem_git_deps.append(line)
-                        else:
-                            git_deps.append(line)
-                    else:
-                        # 패키지명 추출 (버전 지정자 제거)
-                        pkg_name = line.split("==")[0].split(">=")[0].split("<=")[0].split(">")[0].split("<")[0].split("~=")[0].split("[")[0].strip()
-                        
-                        # 특별한 설치가 필요한 패키지들
-                        special_install_packages = ["pytorch3d", "torch-scatter", "torch-sparse", "torch-geometric", "tiny-cuda-nn"]
-                        
-                        if pkg_name in special_install_packages:
-                            problem_git_deps.append(f"# {line} # Requires special installation")
-                            yield f"   → Marked {pkg_name} for special handling"
-                            continue
-                        
-                        # 특정 패키지의 잘못된 버전 수정
-                        if pkg_name == "opencv-python":
-                            if "==4.10.0" in line or "==4.10" in line:
-                                line = "opencv-python>=4.10.0.82"
-                                yield "📝 Fixed opencv-python version (4.10.0 → 4.10.0.82)"
-                        
-                        # 중복 체크
-                        if pkg_name in seen_packages:
-                            # 이미 있는 패키지면 버전 비교
-                            existing = seen_packages[pkg_name]
-                            # 더 구체적인 버전을 선택 (== > >= > 버전 없음)
-                            if "==" in line and "==" not in existing:
-                                seen_packages[pkg_name] = line
-                            elif "==" not in existing and ">=" in line and ">=" not in existing:
-                                seen_packages[pkg_name] = line
-                            # 같은 수준이면 더 최신 버전 선택
-                            elif "==" in line and "==" in existing:
-                                try:
-                                    new_ver = line.split("==")[1]
-                                    old_ver = existing.split("==")[1]
-                                    # 버전 비교 (간단한 문자열 비교)
-                                    if new_ver > old_ver:
-                                        seen_packages[pkg_name] = line
-                                except:
-                                    pass
-                            yield f"   → Resolved duplicate: {pkg_name} - using {seen_packages[pkg_name]}"
-                        else:
-                            seen_packages[pkg_name] = line
-                
-                # 분류된 의존성으로 재구성
-                for pkg_name, dep_line in seen_packages.items():
-                    if any(t in pkg_name.lower() for t in ["torch==", "torch>=", "torch~=", "torch<", "torch>", "torch[", "torchvision", "torchaudio"]):
-                        torch_deps.append(dep_line)
-                    else:
-                        regular_deps.append(dep_line)
-                
-                # gradio 버전 확인
-                has_gradio = any("gradio" in pkg for pkg in seen_packages.keys())
-                if not has_gradio:
-                    regular_deps.append("gradio>=5.35.0")
-                    seen_packages["gradio"] = "gradio>=5.35.0"
-                
-                # torch가 없으면 추가 (CUDA 의존성이 있는 경우)
-                torch_packages = [p for p in seen_packages.keys() if p == "torch"]
-                if not torch_packages and (problem_git_deps or any("torch" in dep for dep in git_deps)):
-                    torch_deps.append("torch>=2.0.0")
-                    yield "⚠️ Added torch dependency for git packages"
-                
-                # CPU 버전 torch로 대체 제안
-                cpu_torch_suggested = False
-                for i, dep in enumerate(torch_deps):
-                    if "torch==" in dep or "torch>=" in dep:
-                        # CUDA 버전이 명시되어 있으면 CPU 버전 제안
-                        if "+cu" in dep:
-                            torch_deps[i] = dep.split("+cu")[0]
-                            cpu_torch_suggested = True
-                
-                if cpu_torch_suggested:
-                    yield "ℹ️ Converted torch to CPU version for HuggingFace Spaces compatibility"
-                
-                # 재정렬된 requirements.txt 작성
-                new_lines = []
-                
-                # 1. 먼저 torch 설치
-                if torch_deps:
-                    new_lines.append("# PyTorch - Must be installed first")
-                    new_lines.extend(sorted(set(torch_deps)))
-                    new_lines.append("")
-                
-                # 2. 일반 의존성
-                if regular_deps:
-                    # 특별한 설치가 필요한 패키지들
-                    special_packages = {
-                        "pytorch3d": "# pytorch3d requires special installation from https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md",
-                        "torch-scatter": "# torch-scatter requires matching torch version",
-                        "torch-sparse": "# torch-sparse requires matching torch version",
-                        "torch-geometric": "# torch-geometric requires special installation"
-                    }
-                    
-                    # 추가 버전 검증 및 수정
-                    validated_deps = []
-                    problematic_versions = {
-                        "opencv-python": {
-                            "4.10.0": "4.10.0.84",
-                            "4.10": "4.10.0.84",
-                            "4.9.0": "4.9.0.80",
-                            "4.8.0": "4.8.0.76"
-                        },
-                        "pillow": {
-                            "10.0": "10.0.0",
-                            "9.5": "9.5.0"
-                        }
-                    }
-                    
-                    skipped_packages = []
-                    
-                    for dep in regular_deps:
-                        pkg_name = dep.split("==")[0].split(">=")[0].split("[")[0].strip()
-                        
-                        # 특별한 설치가 필요한 패키지는 주석 처리
-                        if pkg_name in special_packages:
-                            skipped_packages.append(f"# {dep} {special_packages[pkg_name]}")
-                            yield f"   → Commented out {pkg_name} (requires special installation)"
-                            continue
-                        
-                        # 버전 수정이 필요한 패키지 처리
-                        if pkg_name in problematic_versions and "==" in dep:
-                            version = dep.split("==")[1].strip()
-                            if version in problematic_versions[pkg_name]:
-                                new_version = problematic_versions[pkg_name][version]
-                                new_dep = f"{pkg_name}>={new_version}"
-                                validated_deps.append(new_dep)
-                                yield f"   → Fixed version: {dep} → {new_dep}"
-                            else:
-                                validated_deps.append(dep)
-                        else:
-                            validated_deps.append(dep)
-                    
-                    new_lines.append("# Core dependencies")  
-                    # opencv-python 중복 제거 확인
-                    deduped_regular = []
-                    seen = set()
-                    for dep in sorted(validated_deps):
-                        pkg_name = dep.split("==")[0].split(">=")[0].split("<=")[0].split(">")[0].split("<")[0].split("~=")[0].split("[")[0].strip()
-                        if pkg_name not in seen:
-                            deduped_regular.append(dep)
-                            seen.add(pkg_name)
-                    new_lines.extend(deduped_regular)
-                    new_lines.append("")
-                    
-                    # 특별한 설치가 필요한 패키지들을 주석으로 추가
-                    if skipped_packages:
-                        new_lines.append("# ⚠️ The following packages require special installation:")
-                        new_lines.extend(skipped_packages)
-                        new_lines.append("")
-                
-                # 3. 일반 git 의존성
-                if git_deps:
-                    new_lines.append("# Git dependencies")
-                    new_lines.extend(sorted(set(git_deps)))
-                    new_lines.append("")
-                
-                # 문제가 되는 git 의존성과 특수 패키지는 주석 처리
-                if problem_git_deps:
-                    new_lines.append("")
-                    new_lines.append("# ⚠️ CUDA-dependent packages and special installations")
-                    new_lines.append("# These packages require special installation methods:")
-                    new_lines.append("# - pytorch3d: Install from https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md")
-                    new_lines.append("# - CUDA packages: Require CUDA toolkit and GPU environment")
-                    new_lines.append("#")
-                    for dep in problem_git_deps:
-                        if not dep.startswith("#"):
-                            new_lines.append(f"# {dep}")
-                        else:
-                            new_lines.append(dep)
-                    
-                    # 경고 메시지 출력
-                    yield f"⚠️ Commented out {len(problem_git_deps)} packages requiring special installation"
-                
-                # 빈 줄 제거하고 정리
-                final_lines = []
-                for i, line in enumerate(new_lines):
-                    # 주석 다음에 바로 내용이 있는지 확인
-                    if line.strip() and not (i > 0 and new_lines[i-1].startswith("#") and line == ""):
-                        final_lines.append(line)
-                    elif line == "" and i < len(new_lines) - 1:  # 중간의 빈 줄은 유지
-                        final_lines.append(line)
-                
-                req_path.write_text("\n".join(final_lines), encoding="utf-8")
-                
-                # 의존성 개수 통계
-                total_deps = len(torch_deps) + len(regular_deps) + len(git_deps) + len(problem_git_deps)
-                yield f"✅ Reorganized requirements.txt - Total {total_deps} dependencies (duplicates removed)"
-                if torch_deps:
-                    yield f"   - PyTorch packages: {len(torch_deps)}"
-                if regular_deps:
-                    yield f"   - Regular packages: {len(set(regular_deps))}"
-                if git_deps or problem_git_deps:
-                    yield f"   - Git dependencies: {len(git_deps + problem_git_deps)} ({len(problem_git_deps)} commented)"
-                
-                # pre-requirements.txt는 더 이상 필요하지 않음 (통합된 requirements.txt 사용)
-                # packages.txt도 HF Spaces 기본 환경에서는 불필요
-                
-                # README.md에 로컬 실행 가이드 추가
-                if problem_git_deps:
-                    readme_path = Path(folder) / "README.md"
-                    if readme_path.exists():
-                        try:
-                            existing_readme = readme_path.read_text(encoding="utf-8")
-                            
-                            # YAML 헤더 이후에 로컬 실행 가이드 추가
-                            if "---" in existing_readme:
-                                parts = existing_readme.split("---", 2)
-                                if len(parts) >= 3:
-                                    yaml_header = parts[1]
-                                    content = parts[2]
-                                    
-                                    # repo_id가 정의되지 않았으므로 repo_hf와 username 사용
-                                    repo_id = f"{username}/{slugify(repo_hf)}"
-                                    
-                                    local_guide = f"""
-## ⚠️ GPU/CUDA Requirements
-
-This project contains CUDA-dependent packages that cannot run on standard HuggingFace Spaces (CPU environment).
-
-### Running Locally with GPU
-
-```bash
-# Install CUDA Toolkit (if not installed)
-# Visit: https://developer.nvidia.com/cuda-downloads
-
-# Clone this Space
-git clone https://huggingface.co/spaces/{repo_id}
-cd {repo_id.split('/')[-1]}
-
-# Install PyTorch with CUDA
-pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118
-
-# Uncomment CUDA dependencies in requirements.txt
-# Then install all requirements
-pip install -r requirements.txt
-```
-
-### Enabling GPU on HuggingFace Spaces
-
-To use GPU on this Space:
-1. Go to Settings → Hardware
-2. Select GPU (T4 or A10G) 
-3. Costs apply for GPU usage
-
----
-
-"""
-                                    new_readme = f"---{yaml_header}---\n{local_guide}{content}"
-                                    readme_path.write_text(new_readme, encoding="utf-8")
-                                    yield "📝 Added GPU setup guide to README.md"
-                        except Exception as e:
-                            yield f"⚠️ Could not update README with GPU guide: {str(e)}"
-            except Exception as e:
-                yield f"⚠️ Error processing requirements.txt: {str(e)}"
         
-        # Remove .git directory to save space and avoid issues
         git_dir = os.path.join(folder, '.git')
         if os.path.exists(git_dir):
             shutil.rmtree(git_dir)
             yield "🧹 Removed .git directory"
         
-        # Also clean up .gitattributes to remove LFS tracking
         gitattributes_path = os.path.join(folder, '.gitattributes')
         if os.path.exists(gitattributes_path):
-            yield "🧹 Cleaning .gitattributes file..."
             with open(gitattributes_path, 'r') as f:
                 lines = f.readlines()
             
@@ -1157,56 +581,25 @@ To use GPU on this Space:
                 with open(gitattributes_path, 'w') as f:
                     f.writelines(new_lines)
             else:
-                # Remove empty .gitattributes
                 os.remove(gitattributes_path)
         
-        # 기존 README가 있는지 확인하고 Space 헤더가 없으면 추가
-        readme_path = Path(folder) / "README.md"
-        if readme_path.exists():
-            try:
-                existing_content = readme_path.read_text(encoding="utf-8")
-                # YAML 헤더가 없으면 추가
-                if not existing_content.strip().startswith("---"):
-                    yaml_header = f"""---
-title: {repo_hf.replace("-", " ").title()}
-emoji: 🚀
-colorFrom: blue
-colorTo: green
-sdk: {sdk_type}
-sdk_version: "5.35.0"
-app_file: app.py
-pinned: false
----
-
-"""
-                    new_content = yaml_header + existing_content
-                    readme_path.write_text(new_content, encoding="utf-8")
-                    yield "✅ Updated README.md with Space configuration"
-            except Exception as e:
-                yield f"⚠️ Could not update README.md: {str(e)}"
-        
-        # Create the HuggingFace repo with retries
         yield "🏗️ Creating Hugging Face Space..."
         
         repo_id = f"{username}/{slugify(repo_hf)}"
         space_created = False
         
-        # Space 생성 시도
         for attempt in range(3):
             try:
                 yield f"   Creating Space: {repo_id} (attempt {attempt + 1}/3)"
                 
-                # 먼저 기존 Space가 있는지 확인
                 try:
                     existing_space = api.space_info(repo_id=repo_id, token=hf_token)
                     yield f"   ℹ️ Space already exists: {existing_space.id}"
                     space_created = True
                     break
                 except:
-                    # Space가 없으면 생성
                     pass
                 
-                # Space 생성
                 create_result = api.create_repo(
                     repo_id=repo_id,
                     repo_type="space",
@@ -1216,11 +609,8 @@ pinned: false
                     token=hf_token
                 )
                 
-                # 생성 후 잠시 대기
-                import time
                 time.sleep(3)
                 
-                # 생성 확인
                 space_info = api.space_info(repo_id=repo_id, token=hf_token)
                 yield f"   ✅ Space created successfully: {space_info.id}"
                 space_created = True
@@ -1229,39 +619,13 @@ pinned: false
             except Exception as e:
                 error_msg = str(e)
                 
-                # Rate limit 에러 처리
                 if "429" in error_msg or "Too Many Requests" in error_msg:
-                    yield f"""
-❌ **Rate Limit Error**
-
-You have reached the HuggingFace API rate limit for creating Spaces.
-
-**What this means:**
-- New users have limited Space creation quotas
-- You need to wait before creating more Spaces (usually 17-24 hours)
-- Your limits will increase over time as you use HuggingFace
-
-**Solutions:**
-1. **Wait**: Try again in 17-24 hours
-2. **Use existing Space**: Update an existing Space instead of creating a new one
-3. **Contact HuggingFace**: Email website@huggingface.co if you need immediate access
-4. **Alternative**: Create the Space manually on HuggingFace and upload the files
-
-**Manual Space Creation Steps:**
-1. Go to https://huggingface.co/new-space
-2. Create a Space named: `{repo_hf}`
-3. Select SDK: {sdk_type}
-4. After creation, use the "Files" tab to upload your repository contents
-
-Repository has been cloned to local folder and is ready for manual upload.
-"""
-                    # Rate limit의 경우 재시도하지 않음
-                    raise Exception(f"Rate limit reached. Please try again later or create the Space manually.")
+                    yield f"❌ Rate Limit Error - Try again in 17-24 hours"
+                    raise Exception(f"Rate limit reached.")
                 
                 yield f"   ⚠️ Attempt {attempt + 1} failed: {error_msg[:100]}..."
                 if attempt < 2:
                     yield "   Retrying in 5 seconds..."
-                    import time
                     time.sleep(5)
                 else:
                     yield f"   ❌ Failed to create space after 3 attempts"
@@ -1270,18 +634,15 @@ Repository has been cloned to local folder and is ready for manual upload.
         if not space_created:
             raise Exception("Failed to create space")
         
-        # Check folder size
         folder_size = sum(os.path.getsize(os.path.join(dirpath, filename)) 
                          for dirpath, dirnames, filenames in os.walk(folder) 
-                         for filename in filenames) / (1024 * 1024)  # Size in MB
+                         for filename in filenames) / (1024 * 1024)
         
         yield f"📊 Folder size: {folder_size:.2f} MB"
         
-        # Count remaining files
         file_count = sum(len(files) for _, _, files in os.walk(folder))
         yield f"📁 Total files to upload: {file_count}"
         
-        # Upload to HuggingFace with retry logic
         upload_success = False
         max_retries = 3
         
@@ -1289,11 +650,10 @@ Repository has been cloned to local folder and is ready for manual upload.
             try:
                 if attempt > 0:
                     yield f"📤 Upload attempt {attempt + 1}/{max_retries}..."
-                    import time
-                    time.sleep(5)  # 재시도 전 대기
+                    time.sleep(5)
                 
-                if folder_size > 500:  # If larger than 500MB, use upload_large_folder
-                    yield "📤 Uploading large folder to Hugging Face (this may take several minutes)..."
+                if folder_size > 500:
+                    yield "📤 Uploading large folder to Hugging Face..."
                     api.upload_large_folder(
                         folder_path=folder,
                         repo_id=repo_id,
@@ -1321,17 +681,13 @@ Repository has been cloned to local folder and is ready for manual upload.
                 error_msg = str(upload_error)
                 
                 if "404" in error_msg and attempt < max_retries - 1:
-                    yield f"   ⚠️ Upload failed (404). Space might not be ready yet."
-                    yield "   Waiting 10 seconds before retry..."
-                    import time
+                    yield f"   ⚠️ Upload failed (404). Retrying..."
                     time.sleep(10)
                     
-                    # Space 다시 확인
                     try:
                         space_info = api.space_info(repo_id=repo_id, token=hf_token)
                         yield f"   ✅ Space confirmed to exist"
                     except:
-                        # Space 재생성 시도
                         yield "   🔄 Attempting to recreate space..."
                         try:
                             api.create_repo(
@@ -1348,23 +704,10 @@ Repository has been cloned to local folder and is ready for manual upload.
                 
                 elif "LFS pointer" in error_msg:
                     yield "❌ Upload failed due to remaining LFS pointer files"
-                    yield "🔍 Searching for remaining LFS pointers..."
-                    
-                    # Do another scan for LFS files
-                    lfs_count = 0
-                    for root, dirs, files in os.walk(folder):
-                        for file in files:
-                            filepath = os.path.join(root, file)
-                            if is_lfs_pointer_file(filepath):
-                                lfs_count += 1
-                                if lfs_count <= 5:  # 처음 5개만 표시
-                                    yield f"  Found LFS pointer: {filepath.replace(folder + os.sep, '')}"
-                    if lfs_count > 5:
-                        yield f"  ... and {lfs_count - 5} more LFS pointer files"
                     raise upload_error
                 
                 elif attempt == max_retries - 1:
-                    yield f"❌ Upload failed after {max_retries} attempts: {error_msg[:200]}..."
+                    yield f"❌ Upload failed after {max_retries} attempts"
                     raise upload_error
                 else:
                     yield f"   ⚠️ Upload failed: {error_msg[:100]}..."
@@ -1372,45 +715,28 @@ Repository has been cloned to local folder and is ready for manual upload.
         if not upload_success:
             raise Exception("Upload failed after all retries")
         
-        # Clean up the temporary folder
         shutil.rmtree(folder)
         
         space_url = f"https://huggingface.co/spaces/{repo_id}"
         
-        # 성공 메시지와 상세 정보 출력
         yield f"""
 ✅ **Successfully created Space!**
 
 🔗 **Your Space URL**: {space_url}
 
-📋 **Deployment Summary:**
-- **Space ID**: `{repo_id}`
-- **Source Repository**: {repo_git}
-- **SDK Type**: {sdk_type}
-- **Smart Generation**: {'Enabled' if enable_smart_generation else 'Disabled'}
-- **LFS Files**: {'Skipped' if skip_lfs else 'Included'}
-
-🚀 **Next Steps:**
-1. Click the link above to visit your Space
-2. Wait 2-3 minutes for the initial build to complete
-3. Check the "Logs" tab if you encounter any issues
-4. The Space will automatically rebuild when you make changes
-
-💡 **Tips:**
-- If the build fails, check the requirements.txt file
-- For GPU-required projects, enable GPU in Space Settings
-- You can edit files directly in the Space's Files tab
+📋 **Summary:**
+- Space ID: `{repo_id}`
+- Source: {repo_git}
+- SDK: {sdk_type}
+- Smart Generation: {'Enabled' if enable_smart_generation else 'Disabled'}
+- LFS Files: {'Skipped' if skip_lfs else 'Included'}
 """
         
         if skip_lfs:
-            yield "\n⚠️ **Note**: LFS files were removed. The Space may be missing some large files (videos, models, etc.)"
+            yield "\n⚠️ LFS files were removed."
         
         if enable_smart_generation:
-            yield "\n🤖 **Smart Generation**: An AI-generated Gradio interface was created based on repository analysis"
-        
-        # 추가 안내사항
-        if any(dep.startswith("git+") for dep in analysis.get("dependencies", [])) if enable_smart_generation else False:
-            yield "\n⚠️ **Build Notice**: This repository contains git dependencies that may take longer to build"
+            yield "\n🤖 AI-generated Gradio interface was created"
     
     except subprocess.CalledProcessError as e:
         if os.path.exists(folder):
@@ -1421,7 +747,6 @@ Repository has been cloned to local folder and is ready for manual upload.
             shutil.rmtree(folder)
         yield f"❌ Error: {str(e)}"
 
-# Custom CSS for better styling
 css = """
 .container {
     max-width: 900px;
@@ -1436,133 +761,41 @@ css = """
     font-size: 14px;
     line-height: 1.5;
 }
-.warning-box {
-    background-color: #fff3cd;
-    border: 1px solid #ffeaa7;
-    border-radius: 4px;
-    padding: 12px;
-    margin: 10px 0;
-}
-.error-box {
-    background-color: #f8d7da;
-    border: 1px solid #f5c6cb;
-    border-radius: 4px;
-    padding: 12px;
-    margin: 10px 0;
-}
-.info-box {
-    background-color: #d1ecf1;
-    border: 1px solid #bee5eb;
-    border-radius: 4px;
-    padding: 12px;
-    margin: 10px 0;
-}
 """
 
 with gr.Blocks(css=css) as demo:
-    gr.Markdown("# 🚀 Smart GitHub to Hugging Face Space Cloner")
-    gr.Markdown("""
-    Clone any public GitHub repository and convert it to a Hugging Face Space!
+    gr.Markdown("# 🚀 GitHub to Hugging Face Space Cloner")
     
-    **Features:**
-    - ✅ Automatic handling of Git LFS issues
-    - ✅ Removes problematic LFS pointer files
-    - ✅ Progress updates during cloning
-    - ✅ Support for large repositories
-    - 🤖 **NEW: Smart app.py generation with AI analysis**
-    """)
-    
-    # Check for HF_TOKEN
     if not os.getenv("HF_TOKEN"):
-        gr.Markdown("""
-        <div class="error-box">
-        <strong>❌ HF_TOKEN Required</strong><br>
-        Please set the HF_TOKEN environment variable in your Space settings:
-        <ol>
-            <li>Go to your Space Settings</li>
-            <li>Navigate to "Variables and secrets"</li>
-            <li>Add a new secret: Name = <code>HF_TOKEN</code>, Value = your Hugging Face write token</li>
-            <li>Get a token from: <a href="https://huggingface.co/settings/tokens" target="_blank">https://huggingface.co/settings/tokens</a></li>
-        </ol>
-        </div>
-        """)
+        gr.Markdown("❌ HF_TOKEN Required - Set it in Space settings")
     else:
-        gr.Markdown("""
-        <div class="info-box">
-        <strong>✅ HF_TOKEN Found</strong><br>
-        Ready to clone repositories to your Hugging Face account.
-        </div>
-        """)
-        
-        # Rate limit 경고 추가
-        gr.Markdown("""
-        <div class="warning-box">
-        <strong>⚠️ Rate Limits for New Users</strong><br>
-        New HuggingFace users have limited Space creation quotas:
-        <ul>
-            <li>You can create only a few Spaces per day initially</li>
-            <li>Limits increase over time with account activity</li>
-            <li>If you hit the limit, wait 17-24 hours or update existing Spaces</li>
-            <li>Contact website@huggingface.co for immediate access needs</li>
-        </ul>
-        </div>
-        """)
+        gr.Markdown("✅ HF_TOKEN Found")
     
     with gr.Row():
         with gr.Column():
             repo_git = gr.Textbox(
                 label="GitHub Repository URL",
-                placeholder="https://github.com/username/repository",
-                info="Enter the full URL of the GitHub repository"
+                placeholder="https://github.com/username/repository"
             )
             repo_hf = gr.Textbox(
                 label="Hugging Face Space Name",
-                placeholder="my-awesome-space",
-                info="Choose a name for your new Space (will be slugified)"
+                placeholder="my-awesome-space"
             )
             sdk_choices = gr.Radio(
                 ["gradio", "streamlit", "docker", "static"],
                 label="Space SDK",
-                value="gradio",
-                info="Select the SDK type for your Space"
+                value="gradio"
             )
             skip_lfs = gr.Checkbox(
                 label="Skip Git LFS files",
-                value=True,  # Default to True due to common LFS issues
-                info="Recommended if the repo has large files (videos, models, datasets)"
+                value=True
             )
             enable_smart_generation = gr.Checkbox(
-                label="🤖 Enable Smart app.py Generation (Beta)",
+                label="🤖 Enable Smart app.py Generation",
                 value=False,
-                info="Analyze repository and generate working Gradio interface with AI"
+                info="Requires FIREWORKS_API_KEY in environment variables"
             )
             
-            gr.Markdown("""
-            <div class="warning-box">
-            <strong>⚠️ About Git LFS</strong><br>
-            Many repos use Git LFS for large files. If these files are missing or causing errors, 
-            keeping "Skip Git LFS files" checked will remove them and allow successful cloning.
-            </div>
-            """)
-            
-            # Smart Generation 정보
-            gr.Markdown("""
-            <div class="info-box">
-            <strong>🤖 About Smart Generation</strong><br>
-            When enabled, the system will:
-            <ul>
-                <li>Analyze repository structure and dependencies</li>
-                <li>Search for usage examples and documentation</li>
-                <li>Generate a working Gradio interface using AI</li>
-                <li>Create appropriate requirements.txt</li>
-            </ul>
-            <br>
-            <strong>Required Environment Variables:</strong><br>
-            - <code>OPENAI_API_KEY</code> or <code>FRIENDLI_TOKEN</code> for AI generation<br>
-            - <code>BAPI_TOKEN</code> for web search (optional)
-            </div>
-            """)
-            
             btn = gr.Button("🎯 Clone Repository", variant="primary")
             
         with gr.Column():
@@ -1574,52 +807,11 @@ with gr.Blocks(css=css) as demo:
                 show_copy_button=True
             )
     
-    gr.Markdown("""
-    ### 📝 Instructions:
-    1. **Setup**: Make sure HF_TOKEN is set in your Space settings
-    2. **Repository URL**: Enter the full GitHub repository URL
-    3. **Space Name**: Choose a name for your new Space
-    4. **SDK**: Select the appropriate SDK for your Space
-    5. **LFS Files**: Keep "Skip Git LFS files" checked if unsure
-    6. **Smart Generation**: Enable to automatically create working app.py
-    7. **Clone**: Click "Clone Repository" and monitor progress
-    
-    ### 🚨 Troubleshooting:
-    
-    <div class="error-box">
-    <strong>LFS pointer file errors?</strong><br>
-    Make sure "Skip Git LFS files" is checked. This removes large file pointers that can cause upload failures.
-    </div>
-    
-    - **Missing files after cloning**: The repository used Git LFS for large files that are no longer available
-    - **Slow uploads**: Large repositories take time. Consider using a smaller repository or removing unnecessary files
-    - **Space doesn't work**: Check if removed LFS files were essential (models, data, etc.) and add them manually
-    - **Smart Generation issues**: Make sure you have the required API keys set in environment variables
-    """)
-    
     btn.click(
         fn=clone,
         inputs=[repo_git, repo_hf, sdk_choices, skip_lfs, enable_smart_generation],
         outputs=output
     )
-    
-    # 성공 사례 및 팁
-    gr.Markdown("""
-    ### 🌟 Success Tips:
-    
-    1. **For ML/AI Projects**: Enable GPU in Space Settings after deployment
-    2. **For Large Files**: Use Git LFS or host models on HuggingFace Hub
-    3. **For Complex Dependencies**: Check build logs and adjust requirements.txt
-    4. **For Private APIs**: Add secrets in Space Settings (Settings → Variables and secrets)
-    
-    ### 📊 Supported Project Types:
-    - 🤖 Machine Learning models (PyTorch, TensorFlow, Transformers)
-    - 🖼️ Computer Vision applications  
-    - 📝 NLP and text processing
-    - 🎵 Audio processing and generation
-    - 📈 Data visualization and analysis
-    - 🎮 Interactive demos and games
-    """)
 
 if __name__ == "__main__":
     demo.launch()