Update app-backup.py

app-backup.py

@@ -1,16 +1,8 @@
-#!/usr/bin/env python3
-"""
-HF Space Auto-Deployer - README 오류 수정 버전
-----------------------------------------
-공개 Git 레포지토리를 Hugging Face Gradio Space로 자동 변환 및 배포합니다.
-Git 명령어를 사용하지 않고 HuggingFace API만 사용하는 안정적인 버전입니다.
-
-필요 환경변수:
-- HF_TOKEN: HuggingFace Write Token (선택, UI에서 입력 가능)
-- BAPI_TOKEN: Brave Search API Key (선택)
-- OPENAI_API_KEY 또는 FRIENDLI_TOKEN: AI 생성용 (선택)
-"""
-
+import gradio as gr
+from huggingface_hub import HfApi, create_repo
+from git import Repo
+import uuid 
+from slugify import slugify
 import os
 import sys
 import json
@@ -20,42 +12,287 @@ import tempfile
 import textwrap
 import requests
 import shutil
+import time
 from pathlib import Path
-from typing import Optional, Dict, List
+from typing import Optional, Dict, List, Tuple
 
-import gradio as gr
-from huggingface_hub import HfApi, create_repo
+# ========== 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)
+            return header.startswith(b'version https://git-lfs.github.com/spec/v1')
+    except:
+        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
 
-# ========== Brave Search 헬퍼 (선택적) ========== #
-def brave_search_repo(repo_url: str, count: int = 5) -> List[Dict]:
-    """Brave Search API로 레포지토리 메타데이터 수집"""
+# ========== 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": [],
+        "model_files": [],
+        "data_files": [],
+        "config_files": [],
+        "entry_points": []
+    }
+    
+    # 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}")
+                    else:
+                        cleaned_deps.append(r)
+            analysis["dependencies"] = cleaned_deps
+        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자만
+                
+                # 설명 추출
+                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개만 분석
+        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),
+                        "preview": content[:500]
+                    })
+            except:
+                pass
+    
+    # 모델 파일 찾기
+    model_extensions = [".pth", ".pt", ".ckpt", ".h5", ".pb", ".onnx", ".safetensors"]
+    for ext in model_extensions:
+        model_files = list(src_path.glob(f"**/*{ext}"))
+        for mf in model_files[:5]:
+            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))
+        for cf in config_files[:5]:
+            if ".git" not in str(cf):
+                analysis["config_files"].append(str(cf.relative_to(src_path)))
+    
+    return analysis
+
+# ========== Brave Search 헬퍼 (두 번째 코드에서) ========== #
+def search_repo_info(repo_url: str) -> str:
+    """Brave Search로 레포지토리 정보 수집"""
     api_key = os.getenv("BAPI_TOKEN")
     if not api_key:
-        print("⚠️ BAPI_TOKEN이 설정되지 않아 검색을 건너뜁니다.")
-        return []
+        return ""
     
-    # API 키 정리 (줄바꿈, 공백 제거)
     api_key = api_key.strip()
-    
     headers = {"X-Subscription-Token": api_key, "Accept": "application/json"}
-    params = {"q": f'site:github.com "{repo_url}"', "count": count, "search_lang": "en"}
     
-    try:
-        resp = requests.get(
-            "https://api.search.brave.com/res/v1/web/search",
-            headers=headers, 
-            params=params, 
-            timeout=10
-        )
-        resp.raise_for_status()
-        return resp.json().get("web", {}).get("results", [])
-    except Exception as e:
-        print(f"⚠️ Brave Search 경고: {e}")
-        return []
+    # 레포지토리 이름 추출
+    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 앱 생성"""
+    
+    # 컨텍스트 준비
+    context = f"""Repository URL: {repo_url}
+
+Repository Analysis:
+- Description: {analysis.get('description', 'N/A')}
+- Main Dependencies: {', '.join(analysis['dependencies'][:10])}
+- Entry Points: {', '.join(analysis['entry_points'][:5])}
+- Model Files: {', '.join(analysis['model_files'][:3])}
+- Config Files: {', '.join(analysis['config_files'][:3])}
+
+Key Files Found:
+"""
+    
+    for kf in analysis.get('key_files', [])[:3]:
+        context += f"\n--- {kf['path']} ---\n{kf['preview']}\n"
+    
+    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.
+
+CRITICAL REQUIREMENTS:
+1. The app.py must be FULLY FUNCTIONAL and runnable
+2. DO NOT use 'from agent import' or any repository-specific imports that won't exist
+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
 
-# ========== AI 생성 헬퍼 (선택적) ========== #
-def generate_gradio_app(context: str) -> Dict:
-    """AI로 Gradio 앱 생성 또는 기본 템플릿 반환"""
+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")
@@ -69,13 +306,10 @@ def generate_gradio_app(context: str) -> Dict:
             payload = {
                 "model": "gpt-4o-mini",
                 "messages": [
-                    {
-                        "role": "system",
-                        "content": "You are an expert at creating Gradio apps. Generate a complete, working Gradio app based on the repository context. Return only valid JSON with keys: app_py, requirements_txt, summary. IMPORTANT: Always use gradio>=5.35.0 in requirements_txt."
-                    },
-                    {"role": "user", "content": f"Create a Gradio app for:\n{context[:4000]}"}
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Create a fully functional Gradio app for this repository:\n\n{context[:8000]}"}
                 ],
-                "temperature": 0.7,
+                "temperature": 0.3,
                 "max_tokens": 4000
             }
             
@@ -88,15 +322,32 @@ def generate_gradio_app(context: str) -> Dict:
             
             if r.status_code == 200:
                 response_text = r.json()["choices"][0]["message"]["content"]
-                print("✅ OpenAI API로 앱 생성 성공")
+                print("✅ OpenAI API로 스마트 앱 생성 성공")
                 
                 # JSON 파싱
-                if "```json" in response_text:
-                    start = response_text.find("```json") + 7
-                    end = response_text.find("```", start)
-                    response_text = response_text[start:end].strip()
-                
-                return json.loads(response_text)
+                try:
+                    if "```json" in response_text:
+                        start = response_text.find("```json") + 7
+                        end = response_text.find("```", start)
+                        response_text = response_text[start:end].strip()
+                    elif "```" in response_text:
+                        start = response_text.find("```") + 3
+                        end = response_text.find("```", start)
+                        response_text = response_text[start:end].strip()
+                    
+                    result = json.loads(response_text)
+                    
+                    if not all(key in result for key in ["app_py", "requirements_txt", "summary"]):
+                        raise ValueError("Missing required keys in response")
+                    
+                    if "gradio" not in result.get("requirements_txt", "").lower():
+                        result["requirements_txt"] = "gradio>=5.35.0\n" + result.get("requirements_txt", "")
+                    
+                    return result
+                    
+                except (json.JSONDecodeError, ValueError) as e:
+                    print(f"⚠️ JSON 파싱 오류: {e}")
+                    return None
         except Exception as e:
             print(f"⚠️ OpenAI API 오류: {e}")
     
@@ -104,751 +355,1271 @@ def generate_gradio_app(context: str) -> Dict:
     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"
             ]:
-                headers = {
-                    "Authorization": f"Bearer {friendli_token.strip()}",
-                    "Content-Type": "application/json"
-                }
-                
-                payload = {
-                    "model": "meta-llama-3.1-70b-instruct",
-                    "messages": [
-                        {
-                            "role": "system",
-                            "content": "Generate a Gradio app. Return JSON with keys: app_py, requirements_txt, summary. IMPORTANT: Always use gradio>=5.35.0 in requirements_txt."
-                        },
-                        {"role": "user", "content": f"Create Gradio app for:\n{context[:4000]}"}
-                    ],
-                    "max_tokens": 4000,
-                    "temperature": 0.7
-                }
-                
                 r = requests.post(endpoint, json=payload, headers=headers, timeout=30)
                 if r.status_code == 200:
                     response_text = r.json()["choices"][0]["message"]["content"]
-                    print(f"✅ Friendli API로 앱 생성 성공")
+                    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()
                     
-                    return json.loads(response_text)
+                    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가 없어 기본 템플릿을 사용합니다.")
-    return None
+    # 스마트 기본 템플릿 생성
+    print("ℹ️ AI API가 없어 스마트 기본 템플릿을 생성합니다.")
+    return create_smart_template(repo_url, analysis)
 
-# ========== 메인 배포 함수 ========== #
-def deploy(repo_url: str, hf_token: str, private: bool = False) -> str:
-    """레포지토리를 Gradio Space로 배포 (저장소 내용 그대로 복사)"""
+def create_smart_template(repo_url: str, analysis: Dict) -> Dict:
+    """분석 결과를 바탕으로 스마트한 기본 템플릿 생성"""
     
-    # 토큰 정리
-    hf_token = hf_token.strip()
-    if not hf_token.startswith("hf_"):
-        raise ValueError("잘못된 토큰 형식입니다. 'hf_'로 시작해야 합니다.")
+    repo_name = Path(repo_url.rstrip("/")).name
+    description = analysis.get("description", "A project deployed from GitHub") if analysis else "A project deployed from GitHub"
     
-    # HF API 초기화
-    api = HfApi(token=hf_token)
+    # 의존성 기반 앱 타입 결정
+    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"])
     
-    # 사용자 정보 및 Space 이름 생성
-    try:
-        user_info = api.whoami()
-        user = user_info["name"]
-    except Exception as e:
-        raise RuntimeError(f"HuggingFace 인증 실패: {e}")
+    # 기본 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]
+                    filtered_deps.append(f"{pkg_name}>={version}")
+                else:
+                    filtered_deps.append(dep)
+        requirements.extend(filtered_deps)
     
-    # Space 이름 정리
-    repo_name = Path(repo_url.rstrip("/")).name.lower()
-    repo_name = repo_name.replace(".", "-").replace("_", "-")[:32]  # 32자 제한
-    space_id = f"{user}/{repo_name}-space"
+    # 앱 타입별 템플릿 생성
+    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"
     
-    print(f"\n📦 Space ID: {space_id}")
+    info = """
+    ## ⚠️ Build Requirements Notice
     
-    # Space 생성
-    try:
-        create_repo(
-            repo_id=space_id,
-            repo_type="space",
-            space_sdk="gradio",
-            private=private,
-            token=hf_token,
-            exist_ok=True
-        )
-        print("✅ Space 생성 완료")
-    except Exception as e:
-        print(f"⚠️ Space 생성 오류: {e}")
-        if "already exists" not in str(e):
-            raise
+    This project requires:
+    1. CUDA-enabled GPU
+    2. Custom C++/CUDA extensions compilation
+    3. Specific versions of PyTorch with CUDA support
     
-    with tempfile.TemporaryDirectory() as work_dir:
-        work_path = Path(work_dir)
-        
-        # 원본 레포지토리 클론
-        print("\n📥 레포지토리 클론 중...")
-        src_path = work_path / "source"
-        
-        try:
-            import git
-            # LFS 파일을 포함하여 클론
-            git.Repo.clone_from(repo_url, src_path, depth=1)
-            print("✅ 레포지토리 클론 완료")
-            
-            # Git LFS 파일 체크 및 다운로드 시도
-            try:
-                repo = git.Repo(src_path)
-                # LFS 파일 다운로드 시도
-                repo.git.lfs('pull')
-                print("✅ LFS 파일 다운로드 시도")
-            except Exception as lfs_error:
-                print(f"⚠️ LFS 파일 다운로드 건너뜀: {lfs_error}")
-                
-        except Exception as e:
-            print(f"❌ 레포 클론 실패: {e}")
-            raise
-        
-        # Space에 업로드할 파일들 준비
-        print("\n🔍 레포지토리 파일 분석 중...")
-        
-        # 기본 Gradio app.py가 있는지 확인
-        has_app_py = (src_path / "app.py").exists()
-        has_gradio_app = False
-        
-        # Gradio 관련 파일 찾기
-        gradio_files = []
-        for pattern in ["*gradio*.py", "*demo*.py", "*interface*.py", "*ui*.py"]:
-            gradio_files.extend(src_path.glob(pattern))
-        
-        # requirements.txt 확인
-        has_requirements = (src_path / "requirements.txt").exists()
-        requirements_content = ""
-        
-        if has_requirements:
-            requirements_content = (src_path / "requirements.txt").read_text(encoding="utf-8")
-            # Gradio 버전 확인 및 업데이트
-            if "gradio" not in requirements_content.lower():
-                requirements_content += "\ngradio>=5.35.0"
-            else:
-                # 기존 gradio 버전을 5.35.0으로 업데이트
-                import re
-                requirements_content = re.sub(
-                    r'gradio[>=<~=]*[\d.]*',
-                    'gradio>=5.35.0',
-                    requirements_content,
-                    flags=re.IGNORECASE
-                )
-        else:
-            # requirements.txt가 없으면 기본 생성
-            requirements_content = "gradio>=5.35.0\n"
+    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()}
+    
+    {description}
+    
+    This space was created from: [{repo_url}]({repo_url})
+    
+    **Note**: This project has complex build requirements. See below for details.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            input_file = gr.File(label="Upload 3D File or Image")
+            process_btn = gr.Button("Process", variant="primary")
         
-        # README.md 생성 (YAML 헤더를 정확하게 생성)
-        readme_content = f"""---
-title: {repo_name.replace("-", " ").title()}
-emoji: 🚀
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: "5.35.0"
-app_file: app.py
-pinned: false
----
+        with gr.Column():
+            output_info = gr.Markdown()
+    
+    process_btn.click(
+        fn=process_3d,
+        inputs=input_file,
+        outputs=output_info
+    )
 
-# {repo_name.replace("-", " ").title()}
+if __name__ == "__main__":
+    demo.launch()
+'''
+    elif has_cv:
+        app_code = f'''import gradio as gr
+from PIL import Image
+import numpy as np
 
-Deployed from: {repo_url}
+# Repository: {repo_url}
+# {description}
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-"""
-        
-        # 파일 업로드
-        print("\n📤 Space에 파일 업로드 중...")
-        
-        # 업로드할 파일 목록 생성 (모든 파일 복사)
-        files_to_upload = []
-        
-        # .git 폴더를 제외한 모든 파일 복사
-        for file_path in src_path.rglob("*"):
-            if file_path.is_file() and ".git" not in str(file_path):
-                relative_path = file_path.relative_to(src_path)
-                
-                # README.md는 건너뛰기 (나중에 새로 생성)
-                if str(relative_path).lower() == "readme.md":
-                    continue
-                
-                # LFS 포인터 파일 체크
-                is_lfs_pointer = False
-                try:
-                    with open(file_path, 'rb') as f:
-                        header = f.read(100)
-                        if header.startswith(b'version https://git-lfs.github.com/spec/'):
-                            is_lfs_pointer = True
-                            print(f"  ⚠️ LFS 파일 건너뜀: {relative_path}")
-                except:
-                    pass
-                
-                if is_lfs_pointer:
-                    continue
-                
-                # 대용량 파일 필터링 (100MB 이상)
-                try:
-                    file_size = file_path.stat().st_size
-                    if file_size > 100 * 1024 * 1024:
-                        print(f"  ⚠️ 큰 파일 건너뜀: {relative_path} ({file_size / 1024 / 1024:.1f}MB)")
-                        continue
-                except:
-                    continue
-                
-                # 특정 확장자 필터링 (대용량 미디어 파일)
-                skip_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv',
-                                 '.zip', '.tar', '.gz', '.rar', '.7z',
-                                 '.weights', '.pkl', '.pth', '.h5', '.ckpt'}
-                if file_path.suffix.lower() in skip_extensions:
-                    print(f"  ⚠️ 미디어/아카이브 파일 건너뜀: {relative_path}")
-                    continue
-                
-                files_to_upload.append((str(relative_path), file_path))
-        
-        # app.py가 없고 Gradio 파일도 없으면 기본 app.py 생성
-        if not has_app_py and not gradio_files:
-            print("  ⚠️ app.py가 없어 기본 템플릿 생성")
-            app_content = f'''import gradio as gr
+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}"
+    return processed, info
 
-def main():
-    return f"""
+# Gradio 인터페이스 생성
+with gr.Blocks(title="{repo_name}") as demo:
+    gr.Markdown(f"""
     # {repo_name.replace("-", " ").title()}
     
-    This Space was deployed from: {repo_url}
+    {description}
     
-    The original repository doesn't contain a Gradio app.
-    Please create an app.py file with your Gradio interface.
+    This space was created from: [{repo_url}]({repo_url})
+    """)
     
-    ## Repository Structure
-    Check the Files tab to see all uploaded files from the repository.
-    """
-
-demo = gr.Interface(
-    fn=main,
-    inputs=None,
-    outputs="markdown",
-    title=f"{repo_name.replace("-", " ").title()} - Deployed from GitHub",
-    description="Please edit app.py to add your Gradio interface."
-)
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(label="Input Image", type="pil")
+            process_btn = gr.Button("Process Image", variant="primary")
+        
+        with gr.Column():
+            output_image = gr.Image(label="Output Image")
+            output_info = gr.Textbox(label="Information")
+    
+    process_btn.click(
+        fn=process_image,
+        inputs=input_image,
+        outputs=[output_image, output_info]
+    )
 
 if __name__ == "__main__":
     demo.launch()
 '''
-            # app.py를 파일 목록 맨 앞에 추가
-            files_to_upload.insert(0, ("app.py", app_content))
-        
-        # requirements.txt 업데이트
-        files_to_upload.insert(0, ("requirements.txt", requirements_content))
-        
-        # README.md를 맨 앞에 추가 (항상 새로 생성)
-        files_to_upload.insert(0, ("README.md", readme_content))
-        
-        # 모든 파일을 한 번에 업로드 (rate limit 회피)
-        print("\n📤 파일 준비 중...")
-        
-        # 임시 디렉토리 생성
-        upload_dir = work_path / "upload"
-        upload_dir.mkdir(exist_ok=True)
-        
-        # 파일 준비
-        for file_info in files_to_upload:
-            try:
-                if isinstance(file_info[1], str):
-                    # 문자열 컨텐츠
-                    path_in_repo = file_info[0]
-                    content = file_info[1]
-                    
-                    # 디렉토리 생성
-                    file_path = upload_dir / path_in_repo
-                    file_path.parent.mkdir(parents=True, exist_ok=True)
-                    
-                    # 파일 쓰기
-                    file_path.write_text(content, encoding="utf-8")
-                else:
-                    # 파일 복사
-                    path_in_repo = file_info[0]
-                    src_file = file_info[1]
-                    
-                    # 디렉토리 생성
-                    dst_file = upload_dir / path_in_repo
-                    dst_file.parent.mkdir(parents=True, exist_ok=True)
-                    
-                    # 파일 복사
-                    shutil.copy2(src_file, dst_file)
-                    
-            except Exception as e:
-                print(f"  ⚠️ {path_in_repo} 준비 실패: {e}")
-                continue
-        
-        # 한 번에 모든 파일 업로드
-        try:
-            print("\n📤 Space에 파일 업로드 중...")
-            api.upload_folder(
-                folder_path=upload_dir,
-                repo_id=space_id,
-                repo_type="space",
-                commit_message="Initial deployment from GitHub repository",
-                ignore_patterns=["*.pyc", "__pycache__", ".git*", ".DS_Store"]
-            )
-            print(f"\n✅ 모든 파일 업로드 완료!")
-        except Exception as e:
-            if "429" in str(e):
-                print(f"\n⚠️ Rate limit 오류: {e}")
-                print("\n💡 해결 방법:")
-                print("1. 1시간 후에 다시 시도하세요")
-                print("2. 또는 수동으로 Space를 생성하고 파일을 업로드하세요")
-                print(f"   - Space URL: https://huggingface.co/spaces/{space_id}")
-                raise RuntimeError("Rate limit에 걸렸습니다. 1시간 후 다시 시도해주세요.")
-            else:
-                raise
-        
-
     
-    return f"https://huggingface.co/spaces/{space_id}"
+    elif has_nlp:
+        app_code = f'''import gradio as gr
+
+# Repository: {repo_url}
+# {description}
 
-# ========== Gradio UI ========== #
-def launch_deploy(repo_url: str, private: bool, profile: gr.OAuthProfile | None) -> str:
-    """Gradio UI에서 호출되는 배포 함수"""
+def process_text(text, max_length=100):
+    """텍스트 처리 함수 - 실제 구현으로 교체 필요"""
+    if not text:
+        return "Please enter some text"
     
-    # 토큰 가져오기
-    hf_token = None
+    # 여기에 실제 NLP 처리 로직 구현
     
-    # OAuth 프로필 확인
-    if profile and hasattr(profile, 'token'):
-        hf_token = profile.token
-        if hf_token:
-            hf_token = hf_token.strip()
+    # 데모용 간단�� 처리
+    word_count = len(text.split())
+    char_count = len(text)
     
-    # 환경변수 폴백
-    if not hf_token:
-        hf_token = os.environ.get("HF_TOKEN")
-        if hf_token:
-            hf_token = hf_token.strip()
+    result = f"""
+    **Analysis Results:**
+    - Word count: {word_count}
+    - Character count: {char_count}
+    - Average word length: {char_count/max(word_count, 1):.1f}
+    """
     
-    if not hf_token:
-        return """### ❌ 인증 필요
+    return result
 
-HuggingFace 토큰이 필요합니다. 다음 중 하나의 방법을 사용하세요:
+# Gradio 인터페이스 생성
+with gr.Blocks(title="{repo_name}") as demo:
+    gr.Markdown(f"""
+    # {repo_name.replace("-", " ").title()}
+    
+    {description}
+    
+    This space was created from: [{repo_url}]({repo_url})
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            input_text = gr.Textbox(
+                label="Input Text",
+                placeholder="Enter your text here...",
+                lines=5
+            )
+            max_length = gr.Slider(
+                minimum=10, 
+                maximum=500, 
+                value=100,
+                label="Max Length"
+            )
+            process_btn = gr.Button("Process Text", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Markdown(label="Results")
+    
+    process_btn.click(
+        fn=process_text,
+        inputs=[input_text, max_length],
+        outputs=output_text
+    )
 
-1. **환경변수 설정** (권장)
-   - Space Settings → Variables and secrets
-   - `HF_TOKEN` = `hf_xxxxx...` 추가
-   - Space 재시작
+if __name__ == "__main__":
+    demo.launch()
+'''
+    
+    else:
+        app_code = f'''import gradio as gr
 
-2. **OAuth 로그인** (OAuth 설정 필요)
-   - README.md에 `hf_oauth: true` 추가
-   - 우측 상단에서 로그인
+# Repository: {repo_url}
+# {description}
 
-**토큰 생성**: https://huggingface.co/settings/tokens (Write 권한 필요)"""
+def main_function(input_data):
+    """메인 처리 함수 - 실제 구현으로 교체 필요"""
+    if not input_data:
+        return "Please provide input"
     
-    # URL 검증
-    repo_url = repo_url.strip()
-    if not repo_url:
-        return "### ❌ Repository URL을 입력해주세요."
+    # 여기에 실제 처리 로직 구현
     
-    if not repo_url.startswith(("https://github.com/", "http://github.com/")):
-        return """### ❌ 잘못된 URL 형식
+    result = f"Processed successfully! Input received: {input_data}"
+    return result
 
-GitHub URL 형식으로 입력해주세요.
-예: `https://github.com/username/repository`"""
+# Gradio 인터페이스 생성
+with gr.Blocks(title="{repo_name}") as demo:
+    gr.Markdown(f"""
+    # {repo_name.replace("-", " ").title()}
     
-    # 배포 실행
-    try:
-        space_url = deploy(repo_url, hf_token, private)
+    {description}
+    
+    This space was created from: [{repo_url}]({repo_url})
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            input_data = gr.Textbox(
+                label="Input",
+                placeholder="Enter your input here...",
+                lines=3
+            )
+            process_btn = gr.Button("Process", variant="primary")
         
-        return f"""### ✅ Space 배포 완료! 🎉
-
-**Space URL**: [{space_url}]({space_url})
+        with gr.Column():
+            output_data = gr.Textbox(label="Output")
+    
+    process_btn.click(
+        fn=main_function,
+        inputs=input_data,
+        outputs=output_data
+    )
 
-**다음 단계:**
-1. 위 링크를 클릭하여 Space 방문
-2. 2-3분 정도 빌드 대기
-3. Files 탭에서 `app.py` 편집하여 기능 추가
+if __name__ == "__main__":
+    demo.launch()
+'''
+    
+    return {
+        "app_py": app_code,
+        "requirements_txt": "\n".join(requirements),
+        "summary": f"Smart template created for {repo_name}"
+    }
 
-**Tips:**
-- 빌드 상태는 Logs 탭에서 확인
-- 오류가 있다면 Files → app.py에서 수정
-- requirements.txt에 필요한 패키지 추가"""
+# ========== 통합된 메인 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."
+        return
+    
+    try:
+        # Initialize progress messages
+        yield "🔄 Starting clone process..."
         
-    except Exception as e:
-        error_msg = str(e)
+        # Get user info
+        api = HfApi(token=hf_token)
+        try:
+            user_info = api.whoami()
+            username = user_info["name"]
+            yield f"✅ Authenticated as: {username}"
+        except Exception as e:
+            yield f"❌ Authentication failed: {str(e)}"
+            return
         
-        if "인증 실패" in error_msg or "401" in error_msg:
-            return """### ❌ 인증 실패
-
-토큰이 유효하지 않거나 권한이 부족합니다.
-
-**해결 방법:**
-1. [토큰 생성 페이지](https://huggingface.co/settings/tokens) 방문
-2. New token → **write** 권한 체크
-3. Space Settings에서 HF_TOKEN 업데이트"""
+        # Clone the repository
+        yield f"📥 Cloning repository from {repo_git}..."
         
-        elif "already exists" in error_msg:
-            return """### ⚠️ Space가 이미 존재합니다
-
-동일한 이름의 Space가 이미 있습니다.
-- 기존 Space를 삭제하거나
-- 다른 Repository를 선택하세요"""
+        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)
         
-        elif "LFS pointer pointed to a file that does not exist" in error_msg:
-            return """### ⚠️ LFS 파일 오류
+        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
+                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
+        
+        # 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)
+            
+            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():
+                    try:
+                        existing_reqs = req_path.read_text(encoding="utf-8").strip().split("\n")
+                    except:
+                        existing_reqs = []
+                
+                new_reqs = generated["requirements_txt"].strip().split("\n") if generated["requirements_txt"] else []
+                
+                # 의존성 정리 및 순서 최적화
+                all_reqs = set()
+                git_reqs = []
+                torch_reqs = []
+                regular_reqs = []
+                
+                for req in existing_reqs + new_reqs:
+                    req = req.strip()
+                    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("")  # 빈 줄
+                
+                # 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.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"
+                
+                # README.md 업데이트 - 항상 생성하여 올바른 형식 보장
+                readme_path = folder_path / "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()}
 
-저장소에 Git LFS로 관리되는 대용량 파일이 있지만 실제 파일이 없습니다.
+{analysis.get('description', 'Deployed from GitHub repository')}
 
-**해결 방법:**
+Deployed from: {repo_git}
 
-1. **자동 해결됨**: 
-   - LFS 파일들을 자동으로 제외하고 다시 시도하세요
-   - 비디오, 모델 파일 등은 건너뜁니다
+## 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
+---
 
-2. **수동으로 필요한 파일만 업로드**:
-   - Space를 수동으로 생성
-   - 필요한 코드 파일만 선택적으로 업로드
+# {repo_hf.replace("-", " ").title()}
 
-3. **원본 저장소에서 LFS 파일 다운로드**:
-   ```bash
-   git clone <repo-url>
-   cd <repo-name>
-   git lfs pull
-   ```
+Deployed from: {repo_git}
 
-**참고**: Gradio 앱 실행에 필수적이지 않은 미디어 파일들은 제외해도 됩니다."""
+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"
         
-        elif "429" in error_msg or "rate-limited" in error_msg.lower() or "Rate limit" in error_msg:
-            # Space 이름 생성
-            repo_name = Path(repo_url.rstrip("/")).name.lower()
-            repo_name = repo_name.replace(".", "-").replace("_", "-")[:32]
-            
-            # 사용자 이름 가져오기
+        # requirements.txt 확인 및 문제 해결
+        req_path = Path(folder) / "requirements.txt"
+        if req_path.exists():
             try:
-                api = HfApi(token=hf_token)
-                user_info = api.whoami()
-                user = user_info["name"]
-                space_id = f"{user}/{repo_name}-space"
-                space_url = f"https://huggingface.co/spaces/{space_id}"
-            except:
-                space_url = "https://huggingface.co/new-space"
-            
-            return f"""### ⚠️ Rate Limit 초과
+                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).
 
-HuggingFace API 사용 한도를 초과했습니다.
+### Running Locally with GPU
 
-**🚀 대체 방법 - 수동 배포:**
+```bash
+# Install CUDA Toolkit (if not installed)
+# Visit: https://developer.nvidia.com/cuda-downloads
 
-1. **Space 생성하기**
-   - [새 Space 만들기]({space_url}) 클릭
-   - Space 이름: `{repo_name}-space` (또는 원하는 이름)
-   - SDK: **Gradio** 선택
-   - Create Space 클릭
+# Clone this Space
+git clone https://huggingface.co/spaces/{repo_id}
+cd {repo_id.split('/')[-1]}
 
-2. **파일 업로드하기**
-   - Space의 **Files** 탭 클릭
-   - **+ Add file** → **Upload files** 클릭
-   - 아래 필수 파일들 업로드:
+# 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
 
-<details>
-<summary><b>README.md</b> (클릭해서 펼치기)</summary>
+To use GPU on this Space:
+1. Go to Settings → Hardware
+2. Select GPU (T4 or A10G) 
+3. Costs apply for GPU usage
 
-```markdown
 ---
-title: {repo_name.replace("-", " ").title()}
+
+"""
+                                    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()
+            
+            new_lines = []
+            for line in lines:
+                if 'filter=lfs' not in line:
+                    new_lines.append(line)
+            
+            if new_lines:
+                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: gradio
+sdk: {sdk_type}
 sdk_version: "5.35.0"
 app_file: app.py
 pinned: false
 ---
 
-# {repo_name.replace("-", " ").title()}
-
-Deployed from: {repo_url}
-```
-</details>
-
-<details>
-<summary><b>app.py</b> (클릭해서 펼치기)</summary>
+"""
+                    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",
+                    space_sdk=sdk_type,
+                    exist_ok=True,
+                    private=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
+                break
+                
+            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**
 
-```python
-import gradio as gr
+You have reached the HuggingFace API rate limit for creating Spaces.
 
-def main():
-    return f\"\"\"
-    # Welcome to {repo_name.replace("-", " ").title()}
-    
-    This Space was created from: {repo_url}
-    
-    Please edit this app.py file to add your Gradio interface.
-    \"\"\"
+**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
 
-demo = gr.Interface(
-    fn=main,
-    inputs=None,
-    outputs="markdown",
-    title="{repo_name.replace("-", " ").title()}",
-    description="Edit app.py to customize this Space"
-)
+**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
 
-if __name__ == "__main__":
-    demo.launch()
-```
-</details>
+**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
 
-<details>
-<summary><b>requirements.txt</b> (클릭해서 펼치기)</summary>
+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"   ⚠️ 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"
+                    raise Exception(f"Could not create space: {error_msg}")
+        
+        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
+        
+        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
+        
+        for attempt in range(max_retries):
+            try:
+                if attempt > 0:
+                    yield f"📤 Upload attempt {attempt + 1}/{max_retries}..."
+                    import time
+                    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)..."
+                    api.upload_large_folder(
+                        folder_path=folder,
+                        repo_id=repo_id,
+                        repo_type="space",
+                        token=hf_token,
+                        commit_message="Deploy from GitHub repository",
+                        ignore_patterns=["*.pyc", "__pycache__", ".git*", ".DS_Store", "*.egg-info"]
+                    )
+                else:
+                    yield "📤 Uploading to Hugging Face..."
+                    api.upload_folder(
+                        folder_path=folder,
+                        repo_id=repo_id,
+                        repo_type="space",
+                        token=hf_token,
+                        commit_message="Deploy from GitHub repository",
+                        ignore_patterns=["*.pyc", "__pycache__", ".git*", ".DS_Store", "*.egg-info"]
+                    )
+                
+                upload_success = True
+                yield "✅ Upload completed successfully"
+                break
+                
+            except Exception as upload_error:
+                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
+                    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(
+                                repo_id=repo_id,
+                                repo_type="space",
+                                space_sdk=sdk_type,
+                                exist_ok=True,
+                                private=False,
+                                token=hf_token
+                            )
+                            yield "   ✅ Space recreated"
+                        except Exception as recreate_error:
+                            yield f"   ❌ Could not recreate space: {str(recreate_error)}"
+                
+                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]}..."
+                    raise upload_error
+                else:
+                    yield f"   ⚠️ Upload failed: {error_msg[:100]}..."
+        
+        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!**
 
-```
-gradio>=5.35.0
-```
-</details>
+🔗 **Your Space URL**: {space_url}
 
-3. **GitHub 파일 복사** (선택사항)
-   - GitHub repo의 파일들을 다운로드
-   - Space에 드래그 앤 드롭으로 업로드
+📋 **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'}
 
-**⏰ 자동 배포 재시도:**
-- 1시간 후에 다시 이 도구를 사용하세요
-- 또는 내일 다시 시도하면 한도가 리셋됩니다
+🚀 **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
 
-**💡 팁:** 
-- 새 사용자는 처음에 제한이 있지만 시간이 지나면 한도가 증가합니다
-- 한 번에 너무 많은 Space를 만들지 마세요"""
+💡 **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
+"""
         
-        else:
-            return f"""### ❌ 배포 오류
+        if skip_lfs:
+            yield "\n⚠️ **Note**: LFS files were removed. The Space may be missing some large files (videos, models, etc.)"
+        
+        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"
+    
+    except subprocess.CalledProcessError as e:
+        if os.path.exists(folder):
+            shutil.rmtree(folder)
+        yield f"❌ Git error: {str(e)}"
+    except Exception as e:
+        if os.path.exists(folder):
+            shutil.rmtree(folder)
+        yield f"❌ Error: {str(e)}"
 
-**오류 내용:**
-```
-{error_msg}
-```
+# Custom CSS for better styling
+css = """
+.container {
+    max-width: 900px;
+    margin: auto;
+    padding: 20px;
+}
+.output-box {
+    min-height: 100px;
+    max-height: 400px;
+    overflow-y: auto;
+    font-family: monospace;
+    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;
+}
+"""
 
-**일반적인 해결 방법:**
-1. Repository가 public인지 확인
-2. 토큰이 올바른지 확인 (hf_로 시작)
-3. 인터넷 연결 확인
-4. 잠시 후 다시 시도"""
-
-# ========== UI 생성 ========== #
-def create_ui():
-    """Gradio UI 생성"""
-    
-    with gr.Blocks(
-        title="HF Space Auto-Deployer",
-        theme=gr.themes.Soft(),
-        css="""
-        .main-container { 
-            max-width: 900px; 
-            margin: 0 auto; 
-            padding: 20px;
-        }
-        .header {
-            text-align: center;
-            margin-bottom: 30px;
-            padding: 30px;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            border-radius: 15px;
-            box-shadow: 0 10px 30px rgba(0,0,0,0.1);
-        }
-        .header h1 {
-            margin: 0;
-            font-size: 2.5em;
-            font-weight: bold;
-        }
-        .header p {
-            margin: 10px 0 0 0;
-            font-size: 1.2em;
-            opacity: 0.9;
-        }
-        .status-box {
-            padding: 20px;
-            border-radius: 10px;
-            margin-top: 20px;
-            background-color: #f8f9fa;
-            border: 1px solid #dee2e6;
-        }
-        .info-box {
-            background-color: #e3f2fd;
-            padding: 15px 20px;
-            border-radius: 8px;
-            border-left: 4px solid #2196F3;
-            margin: 15px 0;
-        }
-        .warning-box {
-            background-color: #fff3cd;
-            padding: 15px 20px;
-            border-radius: 8px;
-            border-left: 4px solid #ffc107;
-            margin: 15px 0;
-        }
-        .gr-button-primary {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-            border: none !important;
-            font-size: 1.1em !important;
-            font-weight: bold !important;
-            padding: 12px 30px !important;
-            color: white !important;
-        }
-        .gr-button-primary:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 5px 15px rgba(0,0,0,0.2);
-        }
-        """
-    ) as demo:
-        with gr.Column(elem_classes="main-container"):
-            # 헤더
-            gr.HTML("""
-            <div class="header">
-                <h1>🚀 GitHub → HuggingFace Space</h1>
-                <p>GitHub 저장소를 Gradio Space로 즉시 변환</p>
-            </div>
-            """)
-            
-            # 환경변수 상태 체크
-            env_status = []
-            if os.getenv("HF_TOKEN"):
-                env_status.append("✅ HF_TOKEN 설정됨")
-            else:
-                env_status.append("⚠️ HF_TOKEN 미설정")
-            
-            if os.getenv("OPENAI_API_KEY"):
-                env_status.append("✅ OpenAI API 사용 가능")
-            elif os.getenv("FRIENDLI_TOKEN"):
-                env_status.append("✅ Friendli API 사용 가능")
-            else:
-                env_status.append("ℹ️ AI API 미설정 (기본 템플릿 사용)")
-            
-            if os.getenv("BAPI_TOKEN"):
-                env_status.append("✅ Brave Search 사용 가능")
-            
-            # 상태 표시
-            status_html = "<div class='info-box'><b>🔧 환경 상태:</b><br>" + "<br>".join(env_status) + "</div>"
-            gr.HTML(status_html)
-            
-            # OAuth 로그인 버튼 (OAuth 설정된 경우)
-            if os.getenv("SPACE_ID"):  # Space 환경인 경우
-                gr.LoginButton(value="Sign in with Hugging Face 🤗", size="lg")
-            
-            # 입력 필드
-            with gr.Group():
-                repo_input = gr.Textbox(
-                    label="📦 GitHub Repository URL",
-                    placeholder="https://github.com/username/repository",
-                    info="Public repository URL을 입력하세요",
-                    lines=1
-                )
-                
-                private_checkbox = gr.Checkbox(
-                    label="🔒 Private Space로 생성",
-                    value=False,
-                    info="체크하면 본인만 접근 가능한 Space가 생성됩니다"
-                )
-            
-            # 배포 버튼
-            deploy_btn = gr.Button(
-                "🚀 Space 생성하기",
-                variant="primary",
-                size="lg"
+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!
+    
+    **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>
+        """)
+    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>
+        """)
+    
+    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"
+            )
+            repo_hf = gr.Textbox(
+                label="Hugging Face Space Name",
+                placeholder="my-awesome-space",
+                info="Choose a name for your new Space (will be slugified)"
+            )
+            sdk_choices = gr.Radio(
+                ["gradio", "streamlit", "docker", "static"],
+                label="Space SDK",
+                value="gradio",
+                info="Select the SDK type for your Space"
+            )
+            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)"
+            )
+            enable_smart_generation = gr.Checkbox(
+                label="🤖 Enable Smart app.py Generation (Beta)",
+                value=False,
+                info="Analyze repository and generate working Gradio interface with AI"
             )
             
-            # 결과 출력
-            output_status = gr.Markdown(elem_classes="status-box")
+            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("""
-            ### 💡 예시 Repository
-            - `https://github.com/gradio-app/gradio`
-            - `https://github.com/huggingface/transformers`
-            - `https://github.com/openai/whisper`
+            <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>
             """)
             
-            # 사용 가이드
-            with gr.Accordion("📚 사용 가이드", open=False):
-                gr.Markdown("""
-                ### 필수 설정
-                1. **HF_TOKEN**: Space Settings → Variables and secrets에서 설정
-                   - [토큰 생성](https://huggingface.co/settings/tokens) (write 권한 필요)
-                
-                ### 선택적 설정 (더 나은 결과를 위해)
-                - **OPENAI_API_KEY**: GPT-4로 스마트한 앱 생성
-                - **FRIENDLI_TOKEN**: Llama 3.1로 앱 생성
-                - **BAPI_TOKEN**: 저장소 메타데이터 수집
-                
-                ### 작동 방식
-                1. GitHub repository 분석
-                2. AI가 맞춤형 Gradio 앱 생성 (AI 없으면 기본 템플릿)
-                3. HuggingFace Space에 자동 배포
-                4. 즉시 사용 가능!
-                
-                ### 문제 해결
-                - **토큰 오류**: 토큰이 `hf_`로 시작하는지 확인
-                - **빌드 실패**: Space Logs 확인
-                - **수정 필요**: Files 탭에서 app.py 편집
-                """)
-        
-        # 이벤트 연결
-        deploy_btn.click(
-            fn=launch_deploy,
-            inputs=[repo_input, private_checkbox],
-            outputs=output_status
-        )
-    
-    return demo
-
-# ========== 메인 실행 ========== #
-def main():
-    """메인 실행 함수"""
-    # CLI 인자 파싱
-    parser = argparse.ArgumentParser(description="GitHub repo를 HF Space로 배포")
-    parser.add_argument("--repo_url", help="GitHub repository URL")
-    parser.add_argument("--hf_token", help="HuggingFace write token")
-    parser.add_argument("--private", action="store_true", help="Create private Space")
-    parser.add_argument("--no-ui", action="store_true", help="Run without UI")
-    
-    args = parser.parse_args()
-    
-    # CLI 모드
-    if args.no_ui and args.repo_url and args.hf_token:
-        try:
-            url = deploy(args.repo_url, args.hf_token, args.private)
-            print(f"\n✅ 배포 성공: {url}")
-        except Exception as e:
-            print(f"\n❌ 배포 실패: {e}", file=sys.stderr)
-            sys.exit(1)
+            btn = gr.Button("🎯 Clone Repository", variant="primary")
+            
+        with gr.Column():
+            output = gr.Textbox(
+                label="Progress",
+                lines=15,
+                elem_classes=["output-box"],
+                interactive=False,
+                show_copy_button=True
+            )
     
-    # Gradio UI 모드
-    else:
-        print("\n" + "="*60)
-        print("🚀 HF Space Auto-Deployer 시작")
-        print("="*60)
-        
-        # 환경변수 상태 출력
-        print("\n환경변수 상태:")
-        print(f"  {'✅' if os.getenv('HF_TOKEN') else '❌'} HF_TOKEN")
-        print(f"  {'✅' if os.getenv('OPENAI_API_KEY') else '⚠️'} OPENAI_API_KEY (선택)")
-        print(f"  {'✅' if os.getenv('FRIENDLI_TOKEN') else '⚠️'} FRIENDLI_TOKEN (선택)")
-        print(f"  {'✅' if os.getenv('BAPI_TOKEN') else '⚠️'} BAPI_TOKEN (선택)")
-        
-        print("\n" + "="*60 + "\n")
-        
-        # Gradio 앱 실행
-        demo = create_ui()
-        demo.launch(
-            share=False,
-            server_name="0.0.0.0",
-            server_port=7860
-        )
+    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__":
-    main()
+    demo.launch()