Update app.py

app.py

@@ -3,396 +3,373 @@ import os
 import subprocess
 import tempfile
 import zipfile
+import pathlib
 import shutil
-from pathlib import Path
-import fnmatch # Для базового gitignore-подобного сопоставления (альтернатива pathspec)
 from pathspec import PathSpec
 from pathspec.patterns import GitWildMatchPattern
 
-# --- Константы ---
-DEFAULT_IGNORE_PATTERNS = ".git/, __pycache__/, *.pyc, *.pyo, *.o, *.so, *.a, *.dll, *.dylib, node_modules/, dist/, build/, .env, .venv/, venv/, *.log, *tmp*, *temp*"
-
-# --- Вспомогательные функции ---
+# --- Configuration ---
+DEFAULT_IGNORE_PATTERNS = """
+# Default Ignore Patterns (Gitignore Syntax)
+/.git/
+/.hg/
+/.svn/
+/.vscode/
+/.idea/
+/node_modules/
+/vendor/
+/build/
+/dist/
+/target/
+*.pyc
+*.log
+*.swp
+*~
+__pycache__/
+.DS_Store
+"""
+MAX_OUTPUT_LINES = 10000 # Limit potential output size in display
+INDENT_CHAR = "    " # 4 spaces for indentation
+FOLDER_ICON = "📁"
+FILE_ICON = "📄"
+
+# --- Core Logic ---
+
+def get_repo_path(source_type, repo_url, branch_tag, zip_file_obj, progress=gr.Progress()):
+    """Clones or extracts the repository, returning the local path."""
+    temp_dir = tempfile.mkdtemp()
+    repo_path = None
 
-def get_repo_name_from_url(url):
-    """Извлекает имя репозитория из URL."""
     try:
-        return url.split('/')[-1].replace('.git', '')
-    except Exception:
-        return "repository"
+        if source_type == "URL":
+            if not repo_url:
+                raise ValueError("GitHub Repository URL is required.")
+            progress(0.1, desc="Cloning repository...")
+            git_command = ["git", "clone", "--depth", "1"] # Shallow clone for speed
+            if branch_tag:
+                git_command.extend(["--branch", branch_tag])
+            git_command.extend([repo_url, temp_dir])
 
-def is_binary(filepath):
-    """Проверяет, является ли файл бинарным (упрощенная проверка)."""
-    try:
-        with open(filepath, 'rb') as f:
-            chunk = f.read(1024)
-            return b'\0' in chunk
-    except Exception:
-        return True # Считаем бинарным при ошибке чтения
-
-def create_gitignore_spec(ignore_patterns_str, repo_root):
-    """Создает объект PathSpec из строки паттернов."""
-    patterns = [p.strip() for p in ignore_patterns_str.split(',') if p.strip()]
-    # Добавляем .git/ всегда, если его нет
-    if ".git/" not in patterns and ".git" not in patterns:
-         patterns.append(".git/")
-    # print(f"Using patterns: {patterns}") # Для отладки
-    # Используем GitWildMatchPattern для поддержки синтаксиса .gitignore
-    try:
-        # pathspec ожидает паттерны относительно корня, где находится .gitignore
-        # Если мы находимся в корне репозитория, то пути файлов тоже должны быть относительными к этому корню
-        spec = PathSpec.from_lines(GitWildMatchPattern, patterns)
-        return spec
-    except Exception as e:
-        print(f"Error creating PathSpec: {e}")
-        # Возвращаем пустой spec в случае ошибки парсинга паттернов
-        return PathSpec.from_lines(GitWildMatchPattern, [])
+            print(f"Running command: {' '.join(git_command)}") # For debugging
+            result = subprocess.run(git_command, capture_output=True, text=True, check=False)
 
+            if result.returncode != 0:
+                # Attempt clone without branch if specific one failed (might be default branch)
+                if branch_tag:
+                    progress(0.2, desc=f"Branch '{branch_tag}' not found or clone failed, trying default branch...")
+                    git_command = ["git", "clone", "--depth", "1", repo_url, temp_dir]
+                    print(f"Running command: {' '.join(git_command)}") # For debugging
+                    result = subprocess.run(git_command, capture_output=True, text=True, check=False)
+
+                if result.returncode != 0:
+                  error_message = f"Git clone failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+                  print(error_message) # Log detailed error
+                  # Try to extract a user-friendly message
+                  if "Authentication failed" in result.stderr:
+                       raise ValueError("Authentication failed. Private repositories require different handling (e.g., tokens) which is not supported here.")
+                  elif "not found" in result.stderr:
+                       raise ValueError(f"Repository or branch '{branch_tag or 'default'}' not found at URL: {repo_url}")
+                  else:
+                       raise ValueError(f"Git clone failed. Check URL and branch/tag. Error: {result.stderr.splitlines()[-1] if result.stderr else 'Unknown error'}")
+
+
+            repo_path = pathlib.Path(temp_dir)
+            progress(0.5, desc="Repository cloned.")
+            print(f"Cloned repo to: {repo_path}") # Debugging
+
+        elif source_type == "Upload ZIP":
+            if zip_file_obj is None:
+                raise ValueError("ZIP file upload is required.")
+            progress(0.1, desc="Extracting ZIP file...")
+            zip_path = zip_file_obj.name # Gradio provides a temp file path
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                # Check for common zip structure (single top-level dir)
+                top_level_dirs = list(set(p.split('/')[0] for p in zip_ref.namelist() if '/' in p))
+                extract_target = temp_dir
+                potential_repo_root = temp_dir
+                if len(top_level_dirs) == 1:
+                   # If zip contains repo-main/file structure, extract *into* temp_dir
+                   # The actual repo content will be inside temp_dir/repo-main/
+                   zip_ref.extractall(extract_target)
+                   potential_repo_root = os.path.join(temp_dir, top_level_dirs[0])
+                   print(f"ZIP has single top-level dir: {top_level_dirs[0]}. Potential root: {potential_repo_root}")
+                else:
+                   # Otherwise, extract directly into temp_dir
+                   zip_ref.extractall(extract_target)
+                   print(f"ZIP structure seems flat or multi-root. Using extract target as root: {extract_target}")
+
+                # Basic check if potential_repo_root looks like a valid directory
+                if os.path.isdir(potential_repo_root):
+                    repo_path = pathlib.Path(potential_repo_root)
+                else:
+                     # Fallback if single dir logic failed or wasn't applicable
+                     repo_path = pathlib.Path(extract_target)
+
+
+            progress(0.5, desc="ZIP extracted.")
+            print(f"Extracted ZIP to: {repo_path}") # Debugging
+        else:
+            raise ValueError("Invalid source type selected.")
 
-def generate_markdown_from_path(
-    repo_path,
-    include_content,
-    max_content_kb,
-    ignore_patterns_str,
-    progress=gr.Progress(track_ τότε=True)
+        if not repo_path or not repo_path.is_dir():
+             raise ValueError(f"Could not determine repository root directory within: {temp_dir}")
+
+        return repo_path, temp_dir # Return both the repo content path and the parent temp dir for cleanup
+
+    except Exception as e:
+        # Clean up the temporary directory on error before re-raising
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        print(f"Error in get_repo_path: {e}") # Log error
+        raise e # Re-raise the exception to be caught by the main function
+
+def generate_markdown_structure(
+    repo_root_path: pathlib.Path,
+    include_content: bool,
+    max_size_kb: int,
+    ignore_patterns_str: str,
+    progress=gr.Progress()
 ):
-    """
-    Генерирует Markdown-представление структуры и содержимого каталога.
-    """
-    repo_path_obj = Path(repo_path).resolve()
+    """Generates the Markdown string from the repository structure."""
+    repo_root_path = pathlib.Path(repo_root_path) # Ensure it's a Path object
     markdown_lines = []
-    max_content_bytes = max_content_kb * 1024 if include_content and max_content_kb > 0 else 0
-
-    progress(0, desc="Parsing ignore patterns...")
-    spec = create_gitignore_spec(ignore_patterns_str, repo_path_obj)
-
-    # Используем Path() для упрощения работы с путями
-    root_path = Path(repo_path).resolve()
-    num_files_processed = 0
-    total_items = sum(1 for _ in root_path.rglob('*')) # Приблизительная оценка для прогресс-бара
-
-    markdown_lines.append(f"# Repository Structure: {root_path.name}\n")
-
-    progress(0.1, desc="Walking directory tree...")
-
-    items_to_process = sorted(list(root_path.rglob('*')), key=lambda p: str(p))
-    processed_count = 0
-
-    # Рекурсивная функция для обхода и генерации Markdown
-    def process_directory(current_path, level=0):
-        nonlocal processed_count
-        indent = '  ' * level
-        # Сначала обрабатываем каталоги, затем файлы
-        entries = sorted(list(current_path.iterdir()), key=lambda p: (p.is_file(), p.name))
-
-        for entry in entries:
-            processed_count += 1
-            relative_path_for_match = entry.relative_to(root_path)
-
-            # --- Игнорирование ---
-            # pathspec ожидает строки, добавляем '/' для каталогов для правильного соответствия
-            match_path_str = str(relative_path_for_match)
-            if entry.is_dir():
-                match_path_str += '/'
-
-            is_ignored = spec.match_file(match_path_str)
-            # print(f"Checking '{match_path_str}': ignored={is_ignored}") # Для отладки
-
-            if is_ignored:
-                # print(f"Ignoring: {entry}")
-                # Если директория игнорируется, пропускаем всё её содержимое
-                if entry.is_dir():
-                     # Нужно посчитать все элементы внутри для прогресса
-                     try:
-                         ignored_subtree_count = sum(1 for _ in entry.rglob('*'))
-                         processed_count += ignored_subtree_count
-                     except Exception:
-                         pass # Игнорируем ошибки доступа и т.д.
-                continue # Пропускаем этот элемент
-
-            # Обновляем прогресс
-            progress(min(0.1 + 0.8 * (processed_count / total_items), 0.9) if total_items > 0 else 0.5,
-                     desc=f"Processing: {relative_path_for_match}")
-
-            # --- Генерация Markdown ---
-            if entry.is_dir():
-                markdown_lines.append(f"{indent}- **{entry.name}/**")
-                process_directory(entry, level + 1) # Рекурсивный вызов
-            elif entry.is_file():
-                markdown_lines.append(f"{indent}- {entry.name}")
-                if include_content:
-                    try:
-                        file_size = entry.stat().st_size
-                        if max_content_bytes == 0: # 0 означает без контента
-                            continue
-                        if max_content_bytes > 0 and file_size > max_content_bytes:
-                            markdown_lines.append(f"{indent}  `[Content omitted: File size ({file_size / 1024:.2f} KB) > limit ({max_content_kb} KB)]`")
-                        elif file_size == 0:
-                             markdown_lines.append(f"{indent}  `[File is empty]`")
-                        elif is_binary(entry):
-                            markdown_lines.append(f"{indent}  `[Content omitted: Binary file detected]`")
-                        else:
-                            try:
-                                # Пытаемся читать как UTF-8, затем как Latin-1 если не вышло
-                                file_content = entry.read_text(encoding='utf-8')
-                            except UnicodeDecodeError:
-                                try:
-                                    file_content = entry.read_text(encoding='latin-1')
-                                except Exception as read_err:
-                                     markdown_lines.append(f"{indent}  `[Error reading file: {read_err}]`")
-                                     continue # Пропускаем добавление блока кода при ошибке
-
-                            # Определяем язык для подсветки синтаксиса (опционально)
-                            lang = entry.suffix.lstrip('.')
-                            markdown_lines.append(f"{indent}  ```{lang}\n{file_content}\n{indent}  ```")
-
-                    except OSError as e:
-                        markdown_lines.append(f"{indent}  `[Error accessing file: {e}]`")
-                    except Exception as e:
-                         markdown_lines.append(f"{indent}  `[Unexpected error processing file: {e}]`")
-
-    # Запускаем обработку с корневого каталога
-    process_directory(root_path)
-
-    progress(1, desc="Markdown generated!")
-    return "\n".join(markdown_lines)
-
-
-# --- Основная функция Gradio ---
-
-def process_repository(
-    input_type,
-    repo_url,
-    branch_tag,
-    zip_upload,
-    include_content,
-    max_content_kb,
-    ignore_patterns,
-    progress=gr.Progress(track_progress=True)
+    max_file_size_bytes = max_size_kb * 1024 if max_size_kb > 0 else 0
+
+    # --- Prepare ignore patterns ---
+    # Combine default and user patterns
+    full_ignore_patterns = DEFAULT_IGNORE_PATTERNS.strip() + "\n" + ignore_patterns_str.strip()
+    # Filter out empty lines
+    patterns = [line for line in full_ignore_patterns.splitlines() if line.strip() and not line.strip().startswith('#')]
+    spec = PathSpec.from_lines(GitWildMatchPattern, patterns)
+    print(f"Using ignore patterns: {patterns}") # Debugging
+
+    # --- Add header ---
+    repo_name = repo_root_path.name
+    markdown_lines.append(f"# {FOLDER_ICON} {repo_name}")
+    markdown_lines.append("")
+
+    # --- Walk through the directory ---
+    progress(0.6, desc="Scanning repository structure...")
+    files_processed = 0
+    total_items_estimate = sum(1 for _ in repo_root_path.rglob('*')) # Rough estimate for progress
+
+    items_scanned = 0
+    for item_path in sorted(repo_root_path.rglob('*')):
+        items_scanned += 1
+        if items_scanned % 50 == 0: # Update progress periodically
+             progress(0.6 + (0.3 * (items_scanned / max(1, total_items_estimate))), desc=f"Scanning: {item_path.name}")
+
+
+        relative_path = item_path.relative_to(repo_root_path)
+
+        # Check if the path itself or any of its parent directories should be ignored
+        # Need to check components because pathspec matches relative paths
+        components = relative_path.parts
+        ignored = False
+        # Check root path first for patterns like '/node_modules/'
+        if spec.match_file(str(relative_path)):
+             ignored = True
+        # Check parent directories if a pattern like 'node_modules/' should match anywhere
+        current_check_path = ""
+        for part in components:
+            current_check_path = os.path.join(current_check_path, part)
+            if spec.match_file(current_check_path):
+                ignored = True
+                break
+
+        if ignored:
+            # If it's a directory, prevent os.walk from descending further if we were using it
+            # With rglob, we just skip the current item
+            print(f"Ignoring: {relative_path}") # Debugging
+            continue
+
+        # Calculate depth and indentation
+        depth = len(relative_path.parts) -1 # 0-based depth relative to root content
+        indent = INDENT_CHAR * depth
+
+        # Add entry to Markdown
+        if item_path.is_dir():
+            markdown_lines.append(f"{indent}{FOLDER_ICON} **{item_path.name}/**")
+        elif item_path.is_file():
+            markdown_lines.append(f"{indent}{FILE_ICON} {item_path.name}")
+            files_processed += 1
+
+            # Include file content if requested and within limits
+            if include_content and max_file_size_bytes > 0:
+                try:
+                    file_size = item_path.stat().st_size
+                    if file_size == 0:
+                        markdown_lines.append(f"{indent}{INDENT_CHAR}```")
+                        markdown_lines.append(f"{indent}{INDENT_CHAR}[Empty File]")
+                        markdown_lines.append(f"{indent}{INDENT_CHAR}```")
+                    elif file_size <= max_file_size_bytes:
+                        try:
+                            content = item_path.read_text(encoding='utf-8')
+                            lang = item_path.suffix.lstrip('.')
+                            # Simple lang detection, can be expanded
+                            if not lang: lang = "text"
+
+                            markdown_lines.append(f"{indent}{INDENT_CHAR}```{lang}")
+                            # Indent content lines
+                            content_lines = content.splitlines()
+                            # Limit output lines displayed in Markdown preview if necessary
+                            # Note: The downloaded file will have full content
+                            display_lines = content_lines[:MAX_OUTPUT_LINES]
+                            for line in display_lines:
+                                markdown_lines.append(f"{indent}{INDENT_CHAR}{line}")
+                            if len(content_lines) > MAX_OUTPUT_LINES:
+                                markdown_lines.append(f"{indent}{INDENT_CHAR}[... content truncated in preview ...]")
+                            markdown_lines.append(f"{indent}{INDENT_CHAR}```")
+                        except UnicodeDecodeError:
+                            markdown_lines.append(f"{indent}{INDENT_CHAR}[Content omitted: Not a UTF-8 text file (Size: {file_size} bytes)]")
+                        except Exception as read_err:
+                             markdown_lines.append(f"{indent}{INDENT_CHAR}[Content omitted: Error reading file - {read_err}]")
+                    else:
+                        markdown_lines.append(f"{indent}{INDENT_CHAR}[Content omitted: File size ({file_size} bytes) exceeds limit ({max_file_size_bytes} bytes)]")
+                except OSError as stat_err:
+                    markdown_lines.append(f"{indent}{INDENT_CHAR}[Content omitted: Error accessing file - {stat_err}]")
+
+            elif include_content and max_file_size_bytes == 0: # Content included, but 0 size limit means no content shown
+                 markdown_lines.append(f"{indent}{INDENT_CHAR}[Content omitted: Max file size set to 0 KB]")
+
+
+        # Add a newline for separation, helps readability
+        markdown_lines.append("")
+
+
+    progress(0.95, desc="Formatting output...")
+    final_markdown = "\n".join(markdown_lines)
+    print(f"Processed {files_processed} files.") # Debugging
+    return final_markdown
+
+# --- Gradio Interface ---
+
+def process_repo(
+    source_type, repo_url, branch_tag, zip_file_obj,
+    include_content, max_size_kb, ignore_patterns,
+    progress=gr.Progress(track_tqdm=True)
 ):
-    """
-    Главная функция, вызываемая Gradio. Обрабатывает URL или ZIP.
-    """
-    status_updates = []
-    output_md = ""
-    download_file = None
-
-    temp_dir = tempfile.mkdtemp()
-    repo_path = ""
-    repo_name = "repository"
+    """Main function called by Gradio button."""
+    status = ""
+    output_markdown = ""
+    output_file_path = None
+    repo_root_path = None
+    temp_dir_to_clean = None
 
     try:
-        if input_type == "URL":
-            if not repo_url or not repo_url.startswith(('http://', 'https://')):
-                raise ValueError("Please provide a valid HTTP/HTTPS Git repository URL.")
-
-            repo_name = get_repo_name_from_url(repo_url)
-            repo_path = os.path.join(temp_dir, repo_name)
-            status_updates.append(f"Cloning repository: {repo_url}...")
-            yield "\n".join(status_updates), "", None, progress # Обновляем статус
-
-            git_command = ["git", "clone", "--depth", "1"] # Экономим трафик/время
-            if branch_tag:
-                git_command.extend(["--branch", branch_tag])
-                status_updates.append(f"Using branch/tag: {branch_tag}")
-                yield "\n".join(status_updates), "", None, progress
-            git_command.extend([repo_url, repo_path])
-
-            # progress(0.1, desc="Cloning...") # Начало клонирования
-            # Используем subprocess.run для выполнения команды git
-            result = subprocess.run(git_command, capture_output=True, text=True, check=False) # check=False для ручной проверки
+        progress(0, desc="Starting...")
 
-            if result.returncode != 0:
-                 raise subprocess.CalledProcessError(result.returncode, git_command, output=result.stdout, stderr=result.stderr)
-
-            status_updates.append("Cloning successful.")
-            yield "\n".join(status_updates), "", None, progress
-
-        elif input_type == "Upload ZIP":
-            if zip_upload is None:
-                raise ValueError("Please upload a ZIP file.")
-
-            status_updates.append(f"Processing uploaded ZIP file: {os.path.basename(zip_upload.name)}...")
-            yield "\n".join(status_updates), "", None, progress # Обновляем статус
-
-            repo_name = os.path.splitext(os.path.basename(zip_upload.name))[0]
-            repo_path = os.path.join(temp_dir, repo_name)
-            os.makedirs(repo_path, exist_ok=True)
-
-            # progress(0.1, desc="Extracting ZIP...") # Начало извлечения
-            try:
-                with zipfile.ZipFile(zip_upload.name, 'r') as zip_ref:
-                    # Проверка на "Zip Slip" уязвимость (пути вне целевого каталога)
-                    for member in zip_ref.namelist():
-                        member_path = os.path.abspath(os.path.join(repo_path, member))
-                        if not member_path.startswith(os.path.abspath(repo_path)):
-                            raise SecurityException(f"Attempted Path Traversal in ZIP: {member}")
-                    # Извлечение
-                    zip_ref.extractall(repo_path)
-                status_updates.append("ZIP extraction successful.")
-                yield "\n".join(status_updates), "", None, progress
-            except zipfile.BadZipFile:
-                raise ValueError("Uploaded file is not a valid ZIP archive.")
-            except Exception as e:
-                raise RuntimeError(f"Error extracting ZIP file: {e}")
-
-        else:
-            raise ValueError("Invalid input type selected.")
-
-        # --- Генерация Markdown ---
-        status_updates.append("Generating Markdown structure...")
-        if include_content:
-             status_updates.append(f"Including file content (Max size: {max_content_kb} KB)...")
-        yield "\n".join(status_updates), "", None, progress # Обновляем статус
-
-        # Передаем объект progress в функцию генерации
-        output_md = generate_markdown_from_path(
-            repo_path,
-            include_content,
-            max_content_kb,
-            ignore_patterns if ignore_patterns else DEFAULT_IGNORE_PATTERNS,
-            progress=progress # Передаем объект progress
+        # 1. Get Repository Path
+        yield "Fetching repository...", "", None # Update status, clear outputs
+        repo_root_path, temp_dir_to_clean = get_repo_path(
+            source_type, repo_url, branch_tag, zip_file_obj, progress=progress
         )
+        yield f"Repository ready at: {repo_root_path}", "", None
 
-        status_updates.append("Markdown generation complete.")
+        # 2. Generate Markdown
+        yield "Generating Markdown structure...", "", None
+        markdown_content = generate_markdown_structure(
+            repo_root_path, include_content, int(max_size_kb), ignore_patterns, progress=progress
+        )
 
-        # --- Подготовка файла для скачивания ---
-        output_filename = f"{repo_name}_structure.md"
-        output_filepath = os.path.join(temp_dir, output_filename)
-        with open(output_filepath, "w", encoding="utf-8") as f:
-            f.write(output_md)
-        download_file = output_filepath # Gradio поймет это как путь к файлу для скачивания
+        # 3. Prepare Output File
+        yield "Saving Markdown to file...", markdown_content[:3000] + ("\n\n[... Output truncated in preview ...]" if len(markdown_content)>3000 else ""), None # Show preview
+        output_filename = f"{repo_root_path.name}_structure.md"
+        # Save the file in a place Gradio can access (it manages temp files)
+        # Create a temporary file for Gradio output
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".md", encoding='utf-8') as temp_file:
+             temp_file.write(markdown_content)
+             output_file_path = temp_file.name # Gradio needs the path to this file
 
-        yield "\n".join(status_updates), output_md, download_file, progress
+        yield f"Done. Output file '{output_filename}' ready for download.", markdown_content[:3000] + ("\n\n[... Output truncated in preview ...]" if len(markdown_content)>3000 else ""), gr.File.update(value=output_file_path, visible=True, label=f"Download {output_filename}") # Make file downloadable
 
     except ValueError as ve:
-        status_updates.append(f"Input Error: {ve}")
-        yield "\n".join(status_updates), "", None, gr.Progress(visible=False) # Скрыть прогресс при ошибке
+        print(f"Value Error: {ve}") # Log error
+        yield f"Error: {ve}", "", gr.File.update(value=None, visible=False)
     except subprocess.CalledProcessError as cpe:
-         status_updates.append(f"Git Error: Failed to clone repository.")
-         status_updates.append(f"Command: {' '.join(cpe.cmd)}")
-         status_updates.append(f"Stderr: {cpe.stderr}")
-         status_updates.append(f"Stdout: {cpe.stdout}")
-         yield "\n".join(status_updates), "", None, gr.Progress(visible=False)
-    except SecurityException as se: # Обработка Zip Slip
-        status_updates.append(f"Security Error: {se}")
-        yield "\n".join(status_updates), "", None, gr.Progress(visible=False)
+         error_detail = cpe.stderr or cpe.stdout or "Unknown git error"
+         print(f"Git Error: {error_detail}") # Log error
+         yield f"Git command failed: {error_detail}", "", gr.File.update(value=None, visible=False)
     except Exception as e:
-        status_updates.append(f"An unexpected error occurred: {type(e).__name__}: {e}")
+        print(f"Unexpected Error: {e}") # Log error
         import traceback
-        status_updates.append(f"Traceback:\n{traceback.format_exc()}") # Добавим traceback для отладки
-        yield "\n".join(status_updates), "", None, gr.Progress(visible=False) # Скрыть прогресс при ошибке
-
+        traceback.print_exc() # Print full traceback to logs
+        yield f"An unexpected error occurred: {e}", "", gr.File.update(value=None, visible=False)
     finally:
-        # --- Очистка ---
-        # Не удаляем temp_dir сразу, если download_file указывает на файл внутри него.
-        # Gradio сам управляет временными файлами, которые он возвращает.
-        # Но если мы создали временный каталог для клонирования/извлечения,
-        # который *не* содержит возвращаемый файл напрямую, его нужно удалить.
-        # В данном случае download_file *внутри* temp_dir, Gradio должен справиться.
-        # Для надежности можно скопировать файл в другое временное место,
-        # а потом удалить temp_dir. Но пока оставим так, Gradio обычно чистит за собой.
-        # print(f"Temp directory {temp_dir} contents:")
-        # for item in Path(temp_dir).rglob('*'): print(f"- {item}")
-        # print(f"Cleanup: {temp_dir} - Download file: {download_file}")
-        pass # Оставляем очистку Gradio для возвращенного файла
-
-
-# --- Интерфейс Gradio ---
-
-with gr.Blocks(title="GitHub Repo to Markdown") as demo:
+        # 4. Cleanup
+        if temp_dir_to_clean:
+             print(f"Cleaning up temporary directory: {temp_dir_to_clean}")
+             shutil.rmtree(temp_dir_to_clean, ignore_errors=True)
+             print("Cleanup complete.")
+
+
+# --- Build Gradio UI ---
+
+with gr.Blocks(theme=gr.themes.Default(primary_hue="blue", secondary_hue="cyan")) as demo:
     gr.Markdown("# GitHub Repository to Markdown Converter")
-    gr.Markdown("Convert a GitHub repository (via URL or ZIP) into a single Markdown file representing its structure and optionally content.")
+    gr.Markdown("Convert a GitHub repository's structure (and optionally content) into a single Markdown file.")
 
     with gr.Row():
         with gr.Column(scale=1):
-            input_type = gr.Radio(
-                ["URL", "Upload ZIP"], label="Input Source", value="URL"
+            gr.Markdown("## Input Source")
+            input_source = gr.Radio(
+                ["URL", "Upload ZIP"], label="Select Source Type", value="URL"
             )
 
-            # --- URL Inputs ---
-            with gr.Group(visible=True) as url_inputs:
-                 repo_url = gr.Textbox(
-                     label="Git Repository URL",
-                     placeholder="https://github.com/username/repository.git",
-                     lines=1,
-                 )
-                 branch_tag = gr.Textbox(
-                     label="Branch / Tag (Optional)",
-                     placeholder="main (or specific branch/tag)",
-                     lines=1,
-                 )
-
-            # --- ZIP Upload Input ---
-            with gr.Group(visible=False) as zip_inputs:
-                 zip_upload = gr.File(label="Upload ZIP File", file_types=[".zip"])
-
-
-            # --- Options ---
-            gr.Markdown("### Options")
-            include_content = gr.Checkbox(label="Include File Content in Output", value=False)
-            max_content_kb = gr.Number(
-                label="Max File Size for Content (KB)",
-                value=100,
-                minimum=0,
-                step=10,
-                info="Files larger than this won't have content included. 0 disables all content.",
-                interactive=True # По умолчанию будет активен
-            )
-            ignore_patterns = gr.Textbox(
-                label="Ignore Patterns (comma-separated, gitignore style)",
-                placeholder=".git/, node_modules/, *.log",
-                value=DEFAULT_IGNORE_PATTERNS,
-                lines=2,
-                info="Uses gitignore syntax. Add / for directories. Defaults provided."
+            url_input_group = gr.Group(visible=True) # Show URL by default
+            with url_input_group:
+                repo_url_input = gr.Textbox(label="Git Repository URL", placeholder="https://github.com/user/repo.git")
+                branch_tag_input = gr.Textbox(label="Branch / Tag (Optional)", placeholder="main")
+
+            zip_input_group = gr.Group(visible=False) # Hide ZIP by default
+            with zip_input_group:
+                zip_file_input = gr.File(label="Upload Repository ZIP", file_types=[".zip"])
+
+            # --- Configuration Options ---
+            gr.Markdown("## Configuration")
+            include_content_checkbox = gr.Checkbox(label="Include File Content in Output", value=False)
+            max_size_input = gr.Number(label="Max File Size for Content (KB)", value=100, minimum=0, step=10,
+                                       info="Files larger than this won't have content included. Set to 0 to disable content inclusion entirely, even if checked above.")
+            ignore_patterns_input = gr.Textbox(
+                label="Ignore Patterns (comma-separated or newline, gitignore style)",
+                info="Uses .gitignore syntax. Add / for directories. Default patterns provided.",
+                lines=5,
+                value=DEFAULT_IGNORE_PATTERNS.strip()
             )
 
-            # --- Кнопка запуска ---
             generate_button = gr.Button("Generate Markdown", variant="primary")
 
-            # --- Логика видимости инпутов ---
-            def switch_input_type(choice):
-                return {
-                    url_inputs: gr.update(visible=choice == "URL"),
-                    zip_inputs: gr.update(visible=choice == "Upload ZIP"),
-                }
-            input_type.change(switch_input_type, inputs=input_type, outputs=[url_inputs, zip_inputs])
-
-            # --- Логика активности поля Max Size ---
-            def toggle_max_size(include):
-                return gr.update(interactive=include) # Поле активно, только если контент включен
-            # include_content.change(toggle_max_size, inputs=include_content, outputs=max_content_kb)
-            # Заметка: Убрал авто-деактивацию, т.к. 0 КБ - валидный способ отключить контент.
-            # Пусть пользователь сам решает, даже если галка снята.
-
-
         with gr.Column(scale=2):
-            gr.Markdown("### Status & Output")
-            status_box = gr.Textbox(label="Current Status", lines=5, interactive=False)
-            output_markdown = gr.Textbox(
-                label="Generated Markdown",
-                lines=20,
-                interactive=True, # Позволяет копировать текст
-                show_copy_button=True
-            )
-            download_button = gr.File(label="Download Markdown File", interactive=False)
-
+            gr.Markdown("## Status & Output")
+            status_output = gr.Textbox(label="Current Status", interactive=False, lines=2)
+            # Use a Textbox for preview initially, as Markdown rendering can be slow/heavy
+            markdown_preview_output = gr.Textbox(label="Markdown Preview (Truncated)", interactive=False, lines=20)
+            # Use gr.File for the final download link
+            download_output = gr.File(label="Download Markdown File", visible=False, interactive=False)
+
+
+    # --- Event Handlers ---
+    def toggle_input_visibility(choice):
+        if choice == "URL":
+            return gr.update(visible=True), gr.update(visible=False)
+        else: # ZIP
+            return gr.update(visible=False), gr.update(visible=True)
+
+    input_source.change(
+        fn=toggle_input_visibility,
+        inputs=input_source,
+        outputs=[url_input_group, zip_input_group],
+    )
 
-    # --- Привязка кнопки к функции ---
     generate_button.click(
-        process_repository,
+        fn=process_repo,
         inputs=[
-            input_type,
-            repo_url,
-            branch_tag,
-            zip_upload,
-            include_content,
-            max_content_kb,
-            ignore_patterns,
+            input_source, repo_url_input, branch_tag_input, zip_file_input,
+            include_content_checkbox, max_size_input, ignore_patterns_input
         ],
-        outputs=[status_box, output_markdown, download_button],
+        outputs=[status_output, markdown_preview_output, download_output],
+        # api_name="generate_markdown" # Optional: for API access
     )
 
-# Запуск приложения (для локального тестирования)
+# --- Launch the App ---
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue().launch(debug=True) # Enable queue for handling multiple users, debug=True for local testing