app.py

#!/usr/bin/env python3

import os
import json
import re
from pathlib import Path
from typing import Any, Dict, List, Optional, Set, Tuple
from datetime import datetime, timedelta
from dataclasses import dataclass, field, asdict
from collections import defaultdict
import chardet
from flask import Flask, render_template, request, jsonify, send_file, session
from flask_cors import CORS
import secrets
import tempfile
import random
import logging
from functools import lru_cache
import threading
import time
import urllib.request
import urllib.error
from dotenv import load_dotenv

load_dotenv()

log = logging.getLogger(__name__)


def _load_positive_int_env(name: str, default: int) -> int:
    raw = os.environ.get(name)
    if raw is None:
        return default

    try:
        value = int(raw.strip())
        if value <= 0:
            log.warning("Invalid %s value %r (must be > 0), using default %s", name, raw, default)
            return default
        return value
    except ValueError:
        log.warning("Invalid %s value %r, using default %s", name, raw, default)
        return default


def _load_positive_float_env(name: str, default: float) -> float:
    raw = os.environ.get(name)
    if raw is None:
        return default

    try:
        value = float(raw.strip())
        if value <= 0:
            log.warning("Invalid %s value %r (must be > 0), using default %s", name, raw, default)
            return default
        return value
    except ValueError:
        log.warning("Invalid %s value %r, using default %s", name, raw, default)
        return default

from compressor import SemanticCompressor, LosslessCompressor, HybridCompressor
from dependency_analyzer import DependencyAnalyzer

app = Flask(__name__)
app.secret_key = secrets.token_hex(16)
CORS(app, resources={r"/api/*": {"origins": "*"}})

OPENROUTER_API_KEY = os.environ.get('OPENROUTER_API_KEY')
OPENROUTER_MODEL = os.environ.get('OPENROUTER_MODEL', 'google/gemma-3-27b-it:free')
OPENROUTER_MAX_RETRIES = _load_positive_int_env('OPENROUTER_MAX_RETRIES', 3)
OPENROUTER_API_URL = os.environ.get(
    'OPENROUTER_API_URL',
    'https://openrouter.ai/api/v1/chat/completions'
)

OPENROUTER_REQUEST_TIMEOUT = _load_positive_float_env(
    'OPENROUTER_REQUEST_TIMEOUT',
    _load_positive_float_env('OPENROUTER_TIMEOUT', 120.0),
)
AI_SELECT_MAX_FILES_FOR_PROMPT = _load_positive_int_env('AI_SELECT_MAX_FILES_FOR_PROMPT', 2000)
OPENROUTER_INITIAL_RETRY_DELAY = _load_positive_float_env('OPENROUTER_INITIAL_RETRY_DELAY', 1.0)
OPENROUTER_MAX_RETRY_DELAY = _load_positive_float_env('OPENROUTER_MAX_RETRY_DELAY', 30.0)
OPENROUTER_RETRY_JITTER_SECONDS = _load_positive_float_env('OPENROUTER_RETRY_JITTER_SECONDS', 0.4)
OPENROUTER_GENERATION_CONFIG: Dict[str, Any] = {
    'temperature': _load_positive_float_env('OPENROUTER_TEMPERATURE', 0.7),
    'top_p': _load_positive_float_env('OPENROUTER_TOP_P', 0.95),
    'max_tokens': _load_positive_int_env('OPENROUTER_MAX_TOKENS', 8192),
}


def sanitize_output_filename(requested_filename: Any, compression_type: str) -> str:
    extension = 'md' if compression_type == 'none' else 'json'

    if isinstance(requested_filename, str):
        requested_filename = requested_filename.strip()
    else:
        requested_filename = ''

    if not requested_filename:
        return ''

    filename = Path(requested_filename).name
    filename = re.sub(r'[\\/:*?"<>|]', '_', filename).strip(' .')
    if not filename:
        return ''

    stem = Path(filename).stem.strip(' .')
    if not stem:
        return ''

    return f'{stem}.{extension}'


_FILENAME_QUERY_STOPWORDS = {
    'and',
    'or',
    'then',
    '및',
    '또는',
    '및은',
    'and/or',
    'or/and'
}


def _normalize_filename_token(token: str) -> str:
    return token.strip().strip('`"\'()[]{}<>;,::')


def _is_version_like_token(token: str) -> bool:
    token_lower = token.lower()
    return bool(re.fullmatch(r"\d+(?:\.\d+)+", token_lower))


def _is_likely_filename_token(
    token: str,
    *,
    known_filenames: Set[str],
    known_extensions: Set[str]
) -> bool:
    if not token:
        return False

    lowered = token.lower()
    if lowered in known_filenames:
        return True

    has_path_sep = '/' in token or '\\' in token
    has_dot = '.' in token
    if not has_path_sep and not has_dot:
        return False

    if has_path_sep:
        return len(token.strip('/\\')) > 0

    if _is_version_like_token(lowered):
        return False

    suffix = Path(token).suffix.lower()
    if suffix and suffix in known_extensions:
        return True

    return suffix in known_filenames


def _extract_filename_only_candidates(
    query: str,
    *,
    known_filenames: Optional[Set[str]] = None,
    known_extensions: Optional[Set[str]] = None
) -> List[str]:
    if not isinstance(query, str):
        return []

    query = query.strip()
    if not query:
        return []

    tokens = re.findall(r"[^\s,]+", query)
    if not tokens:
        return []

    known_filenames = known_filenames or set()
    known_extensions = known_extensions or set()

    candidates: List[str] = []
    seen = set()

    for token in tokens:
        normalized = _normalize_filename_token(token)
        if not normalized:
            continue

        if not _is_likely_filename_token(
            normalized,
            known_filenames=known_filenames,
            known_extensions=known_extensions
        ):
            continue

        lowered = normalized.lower()
        if lowered in seen:
            continue
        seen.add(lowered)
        candidates.append(normalized)

    return candidates


def _build_ai_file_manifest(
    all_files: Dict[str, Any],
    query: str,
    *,
    max_files: int
) -> List[Dict[str, str]]:
    if max_files <= 0:
        return []

    manifest: List[Dict[str, str]] = []

    for file_id, file_info in all_files.items():
        if not isinstance(file_id, str) or not isinstance(file_info, dict):
            continue

        relative_path = file_info.get('relative_path')
        if not isinstance(relative_path, str) or not relative_path:
            continue

        compact_entry: Dict[str, str] = {
            'id': file_id,
            'relative_path': relative_path,
        }

        extension = Path(relative_path).suffix.lower()
        if extension:
            compact_entry['extension'] = extension

        manifest.append(compact_entry)

    if not manifest:
        return []

    manifest.sort(key=lambda file_entry: file_entry['relative_path'].lower())

    if len(manifest) <= max_files:
        return manifest

    query_terms = [
        _normalize_filename_token(token).lower()
        for token in re.findall(r"[^\s,]+", query or '')
        if _normalize_filename_token(token)
    ]
    query_terms = [
        term for term in query_terms
        if term and term not in _FILENAME_QUERY_STOPWORDS
    ]

    if not query_terms:
        return manifest[:max_files]

    scored_files: List[Tuple[float, str, Dict[str, str]]] = []
    for file_entry in manifest:
        lower_path = file_entry['relative_path'].lower()
        lower_name = Path(lower_path).name
        score = 0.0

        for term in query_terms:
            if term in lower_path:
                score += 1.0
            if term == lower_name:
                score += 2.0

        if score > 0:
            scored_files.append((score, lower_path, file_entry))

    if not scored_files:
        return manifest[:max_files]

    scored_files.sort(key=lambda item: (item[0], item[1]), reverse=True)

    return [entry for _, _, entry in scored_files[:max_files]]


def _is_pure_filename_query(query: str, candidates: List[str]) -> bool:
    if not candidates:
        return False

    normalized_candidates = {candidate.lower() for candidate in candidates}
    has_any_candidate = False

    for raw_token in re.findall(r"[^\s,]+", query):
        token = _normalize_filename_token(raw_token).lower()
        if not token:
            continue

        if token in _FILENAME_QUERY_STOPWORDS:
            continue

        if token in normalized_candidates:
            has_any_candidate = True
            continue

        return False

    return has_any_candidate

if not OPENROUTER_API_KEY:
    raise ValueError("OPENROUTER_API_KEY environment variable is not set")

TEMP_DIR = Path(tempfile.gettempdir()) / "source_aggregator"
TEMP_DIR.mkdir(exist_ok=True)

ORIGINALS_DIR = TEMP_DIR / "originals"
ORIGINALS_DIR.mkdir(exist_ok=True)

SESSION_TIMEOUT = timedelta(hours=2)

# Initialize with enhanced model configuration

@dataclass
class FileInfo:
    path: str
    size: int
    extension: str
    relative_path: str
    selected: bool = False
    id: str = ""
    last_modified: float = 0
    
    def __post_init__(self):
        if not self.id:
            self.id = self.relative_path.replace('/', '_').replace('.', '_').replace('-', '_')

@dataclass
class DirectoryInfo:
    path: str
    name: str
    relative_path: str
    file_count: int = 0
    total_size: int = 0
    children: List[Dict] = field(default_factory=list)
    files: List[Dict] = field(default_factory=list)
    selected: bool = False
    expanded: bool = False
    id: str = ""
    
    def __post_init__(self):
        if not self.id:
            self.id = self.relative_path.replace('/', '_').replace('.', '_').replace('-', '_')

class WebSourceAggregator:
    
    DEFAULT_EXTENSIONS = {
        '.py', '.js', '.jsx', '.ts', '.tsx', '.java', '.c', '.cpp', '.h', '.hpp',
        '.cs', '.php', '.rb', '.go', '.rs', '.swift', '.kt', '.scala', '.r',
        '.html', '.css', '.scss', '.sass', '.less',
        '.json', '.xml', '.yaml', '.yml', '.toml', '.ini', '.conf', '.config',
        '.sql', '.sh', '.bash', '.zsh', '.fish', '.ps1', '.bat', '.cmd',
        '.dockerfile', '.dockerignore', '.gitignore', '.env', '.env.example',
        '.md', '.txt', '.rst', '.tex',
        '.vue', '.svelte', '.astro',
        '.prisma', '.graphql', '.proto'
    }
    
    DEFAULT_EXCLUDE_DIRS = {
        '.git', '.svn', '.hg', '.bzr',
        'node_modules', '__pycache__', '.pytest_cache', '.mypy_cache',
        'venv', 'env', '.venv', '.env', 'virtualenv',
        'dist', 'build', 'out', 'target', 'bin', 'obj',
        '.idea', '.vscode', '.vs', '.sublime',
        'coverage', '.coverage', 'htmlcov',
        '.next', '.nuxt', '.cache', '.parcel-cache',
        'vendor', 'packages', 'bower_components'
    }
    
    # Method to check if a directory should be excluded
    def _should_exclude_dir(self, dir_name: str) -> bool:
        # Exclude directories starting with .
        if dir_name.startswith('.'):
            return True
        # Exclude directories in DEFAULT_EXCLUDE_DIRS
        if dir_name in self.DEFAULT_EXCLUDE_DIRS:
            return True
        return False
    
    def __init__(self, root_dir: str, max_file_size_mb: float = 10):
        self.root_dir = Path(root_dir).resolve()
        self._validate_root_dir()
        self.max_file_size = max_file_size_mb * 1024 * 1024
        self.all_files = {}
        self.all_directories = {}
        self.file_extensions = defaultdict(list)
        self.errors = []
        self.search_index = {}
    
    def _validate_root_dir(self):
        if not self.root_dir.exists():
            raise ValueError(f"Directory does not exist: {self.root_dir}")
        if not self.root_dir.is_dir():
            raise ValueError(f"Path is not a directory: {self.root_dir}")
        
        try:
            os.listdir(self.root_dir)
        except PermissionError:
            raise ValueError(f"Permission denied: {self.root_dir}")
    
    def analyze_directory_structure(self) -> Dict:
        
        def analyze_dir(dir_path: Path, parent_path: Optional[Path] = None) -> Dict:
            relative_path = str(dir_path.relative_to(self.root_dir)) if dir_path != self.root_dir else "."
            
            dir_info = DirectoryInfo(
                path=str(dir_path),
                name=dir_path.name if dir_path != self.root_dir else self.root_dir.name,
                relative_path=relative_path
            )
            
            try:
                items = sorted(dir_path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
                
                for item in items:
                    if item.is_dir() and not self._should_exclude_dir(item.name):
                        try:
                            child_data = analyze_dir(item, dir_path)
                            dir_info.children.append(child_data)
                            dir_info.file_count += child_data['file_count']
                            dir_info.total_size += child_data['total_size']
                        except PermissionError:
                            continue
                
                for item in items:
                    if item.is_file():
                        try:
                            # Get relative path to check for hidden directories in the path
                            relative_path = str(item.relative_to(self.root_dir))
                            path_parts = relative_path.split('/')
                            
                            # Check if file is hidden or in a hidden directory
                            is_hidden = item.name.startswith('.')
                            is_in_hidden_dir = any(part.startswith('.') for part in path_parts[:-1])
                            is_lock_file = 'lock' in item.name.lower() and item.name.endswith(('.yaml', '.yml', '.json'))
                            
                            # Skip hidden files, files in hidden directories, and lock files
                            if is_hidden or is_in_hidden_dir or is_lock_file:
                                continue
                                
                            file_stat = item.stat()
                            if file_stat.st_size <= self.max_file_size:
                                file_info = FileInfo(
                                    path=str(item),
                                    size=file_stat.st_size,
                                    extension=item.suffix.lower(),
                                    relative_path=relative_path,
                                    last_modified=file_stat.st_mtime
                                )
                                
                                file_dict = asdict(file_info)
                                dir_info.files.append(file_dict)
                                dir_info.file_count += 1
                                dir_info.total_size += file_stat.st_size
                                
                                self.all_files[file_info.id] = file_dict
                                self.file_extensions[file_info.extension].append(file_dict)
                                
                                self._index_file_for_search(file_info)
                        except Exception as e:
                            self.errors.append({'path': str(item), 'error': str(e)})
            
            except PermissionError as e:
                self.errors.append({'path': str(dir_path), 'error': f"Permission denied: {e}"})
            
            dir_dict = asdict(dir_info)
            self.all_directories[dir_info.id] = dir_dict
            return dir_dict
        
        root_structure = analyze_dir(self.root_dir)
        
        extension_stats = {}
        for ext, files in self.file_extensions.items():
            if ext:
                total_size = sum(f['size'] for f in files)
                extension_stats[ext] = {
                    'count': len(files),
                    'size': total_size,
                    'extension': ext
                }
        
        return {
            'tree': root_structure,
            'stats': {
                'total_files': len(self.all_files),
                'total_dirs': len(self.all_directories),
                'extensions': sorted(extension_stats.values(), key=lambda x: x['count'], reverse=True),
                'errors': len(self.errors)
            }
        }
    
    def _index_file_for_search(self, file_info: FileInfo):
        filename = Path(file_info.relative_path).name.lower()
        relative_path_lower = file_info.relative_path.lower()
        
        words = re.findall(r'\w+', filename)
        for word in words:
            if word not in self.search_index:
                self.search_index[word] = []
            self.search_index[word].append(file_info.id)
        
        if relative_path_lower not in self.search_index:
            self.search_index[relative_path_lower] = []
        self.search_index[relative_path_lower].append(file_info.id)
    
    def search_files(self, query: str) -> List[Dict]:
        if not query:
            return []
        
        query_lower = query.lower()
        matched_file_ids = set()
        
        for word in re.findall(r'\w+', query_lower):
            for index_key, file_ids in self.search_index.items():
                if word in index_key:
                    matched_file_ids.update(file_ids)
        
        for path_key, file_ids in self.search_index.items():
            if query_lower in path_key:
                matched_file_ids.update(file_ids)
        
        results = []
        for file_id in matched_file_ids:
            if file_id in self.all_files:
                file_info = self.all_files[file_id].copy()
                file_info['match_score'] = self._calculate_match_score(
                    file_info['relative_path'], query_lower
                )
                results.append(file_info)
        
        return sorted(results, key=lambda x: x['match_score'], reverse=True)
    
    def _calculate_match_score(self, path: str, query: str) -> float:
        path_lower = path.lower()
        filename = Path(path).name.lower()
        
        score = 0.0
        
        if query == filename:
            score += 100.0
        elif query in filename:
            score += 50.0
        elif query in path_lower:
            score += 25.0
        
        query_words = set(re.findall(r'\w+', query))
        path_words = set(re.findall(r'\w+', path_lower))
        
        if query_words:
            word_match_ratio = len(query_words & path_words) / len(query_words)
            score += word_match_ratio * 20.0
        
        if path_lower.startswith(query):
            score += 10.0
        
        return score
    
    def select_files_by_names(self, filenames: List[str]) -> Dict[str, List[str]]:
        selected = []
        not_found = []
        
        for filename in filenames:
            filename_lower = filename.lower()
            found = False
            
            for file_id, file_info in self.all_files.items():
                file_path = file_info['relative_path']
                if filename_lower in file_path.lower():
                    selected.append(file_id)
                    found = True
            
            if not found:
                not_found.append(filename)
        
        return {
            'selected': selected,
            'not_found': not_found
        }
    
    def generate_markdown(self, selected_files: List[str], compression_type: str = 'none') -> Tuple[str, Optional[Dict]]:
        lines = []
        
        lines.append("# Aggregated Source Code")
        lines.append(f"\n**Generated at:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        lines.append(f"**Root Directory:** `{self.root_dir}`")
        lines.append(f"**Total Files:** {len(selected_files)}")
        lines.append(f"**Compression Type:** {compression_type}")
        
        lines.append("\n## Table of Contents\n")
        for i, file_id in enumerate(selected_files, 1):
            if file_id in self.all_files:
                file_info = self.all_files[file_id]
                lines.append(f"{i}. [{file_info['relative_path']}](#{file_id})")
        
        lines.append("\n---\n")
        
        for file_id in selected_files:
            if file_id in self.all_files:
                file_info = self.all_files[file_id]
                file_path = Path(file_info['path'])
                
                lines.append(f"\n## {file_info['relative_path']}\n")
                lines.append(f"**File Size:** {self._format_size(file_info['size'])}  ")
                lines.append(f"**Last Modified:** {datetime.fromtimestamp(file_info['last_modified']).strftime('%Y-%m-%d %H:%M:%S')}  ")
                lines.append("")
                
                try:
                    content, language = self._read_file_content(file_path)
                    lines.append(f"```{language}")
                    lines.append(content)
                    lines.append("```")
                except Exception as e:
                    lines.append(f"**Error reading file:** {e}")
                
                lines.append("\n---")
        
        markdown_content = '\n'.join(lines)
        
        # Use unified compression factory
        from compressor import compress_markdown_unified
        
        return compress_markdown_unified(markdown_content, compression_type)
        
    
    def _format_size(self, size_bytes: int) -> str:
        size_value = float(size_bytes)
        for unit in ['B', 'KB', 'MB', 'GB']:
            if size_value < 1024.0:
                return f"{size_value:.2f} {unit}"
            size_value /= 1024.0
        return f"{size_value:.2f} TB"
    
    @lru_cache(maxsize=128)
    def _detect_encoding(self, file_path: str) -> str:
        try:
            with open(file_path, 'rb') as f:
                raw_data = f.read(10000)
                result = chardet.detect(raw_data)
                encoding = result.get('encoding', 'utf-8')
                
                if not encoding or result.get('confidence', 0) < 0.7:
                    encoding = 'utf-8'
                
                return encoding
        except Exception:
            return 'utf-8'
    
    def _read_file_content(self, file_path: Path) -> tuple:
        language_map = {
            '.py': 'python', '.js': 'javascript', '.jsx': 'jsx',
            '.ts': 'typescript', '.tsx': 'tsx', '.java': 'java',
            '.c': 'c', '.cpp': 'cpp', '.h': 'c', '.hpp': 'cpp',
            '.cs': 'csharp', '.php': 'php', '.rb': 'ruby',
            '.go': 'go', '.rs': 'rust', '.swift': 'swift',
            '.kt': 'kotlin', '.scala': 'scala', '.r': 'r',
            '.html': 'html', '.css': 'css', '.scss': 'scss',
            '.json': 'json', '.xml': 'xml', '.yaml': 'yaml',
            '.yml': 'yaml', '.sql': 'sql', '.sh': 'bash',
            '.md': 'markdown', '.txt': 'text'
        }
        
        suffix = file_path.suffix.lower()
        language = language_map.get(suffix, 'text')
        
        if file_path.name == 'Dockerfile':
            language = 'dockerfile'
        elif file_path.name in ['Makefile', 'makefile']:
            language = 'makefile'
        
        encoding = self._detect_encoding(str(file_path))
        
        with open(file_path, 'r', encoding=encoding, errors='replace') as f:
            content = f.read()
        
        return content, language

class OpenRouterAPIError(RuntimeError):
    def __init__(
        self,
        status_code: int,
        message: str,
        *,
        provider: Optional[str] = None,
        error_code: Optional[Any] = None,
        retry_after: Optional[float] = None,
        raw_payload: Optional[Dict[str, Any]] = None,
        raw_body: str = ''
    ) -> None:
        super().__init__(message)
        self.status_code = status_code
        self.error = message
        self.provider = provider
        self.error_code = error_code
        self.retry_after = retry_after
        self.raw_payload = raw_payload
        self.raw_body = raw_body

    def is_quota_error(self) -> bool:
        message = (self.error or '').lower()
        return self.status_code == 429 and (
            'quota' in message
            or 'exceed' in message
            or 'rate' in message
        )


class OpenRouterFileAnalyzer:
    def __init__(self, model_name: Optional[str] = None):
        self.model_name = model_name or OPENROUTER_MODEL

    def _post_openrouter_request(self, prompt: str) -> str:
        payload: Dict[str, Any] = {
            'model': self.model_name,
            'messages': [
                {
                    'role': 'system',
                    'content': (
                        'You are a strict JSON-only code analysis assistant. '
                        'Return valid JSON only.'
                    )
                },
                {
                    'role': 'user',
                    'content': prompt
                }
            ]
        }
        payload.update(OPENROUTER_GENERATION_CONFIG)

        data = json.dumps(payload).encode('utf-8')
        request = urllib.request.Request(
            OPENROUTER_API_URL,
            data=data,
            headers={
                'Authorization': f'Bearer {OPENROUTER_API_KEY}',
                'Content-Type': 'application/json',
                'HTTP-Referer': 'http://localhost',
                'X-Title': 'CodeWeaver AI File Selector'
            },
            method='POST'
        )

        try:
            with urllib.request.urlopen(request, timeout=OPENROUTER_REQUEST_TIMEOUT) as response:
                response_text = response.read().decode('utf-8')
        except urllib.error.HTTPError as e:
            error_body = ''
            try:
                error_body = e.read().decode('utf-8', errors='replace')
            except Exception:
                error_body = e.reason if isinstance(e.reason, str) else ''

            parsed_error = self._parse_openrouter_error_payload(error_body)
            provider_name, provider_message, error_code = self._extract_provider_error_info(parsed_error)

            retry_after = self._extract_retry_after(parsed_error, e.headers, error_body)
            if (e.code == 429 and retry_after is None and provider_message):
                retry_after = self._extract_retry_after_from_message(provider_message)

            error_message = provider_message if provider_message else f'OpenRouter API request failed ({e.code}): {error_body or e.reason}'
            app.logger.error(f'OpenRouter API request failed ({e.code}): {error_message}')

            raise OpenRouterAPIError(
                status_code=e.code or 0,
                message=error_message,
                provider=provider_name,
                error_code=error_code,
                retry_after=retry_after,
                raw_payload=parsed_error,
                raw_body=error_body
            )
        except urllib.error.URLError as e:
            app.logger.error(f'OpenRouter API request failed: {e.reason}')
            raise OpenRouterAPIError(
                status_code=503,
                message=f'OpenRouter API request failed: {e.reason}',
                error_code='network_error'
            )

        response_payload = json.loads(response_text)
        choices = response_payload.get('choices', [])
        if not choices:
            raise ValueError('No choices returned by OpenRouter API')

        message = choices[0].get('message', {})
        content = message.get('content', '')
        if not content:
            raise ValueError('Empty content returned by OpenRouter API')
        return str(content)
    
    def analyze_files_for_query(
        self,
        query: str,
        file_structure: Dict[str, Any]
    ) -> Dict[str, Any]:
        prompt = self._build_analysis_prompt(query, file_structure)
        
        try:
            attempts = 0
            last_error = None
            response_text = ''
            retryable_status = {429, 500, 502, 503, 504}

            while attempts < OPENROUTER_MAX_RETRIES:
                try:
                    response_text = self._post_openrouter_request(prompt)
                    last_error = None
                    break
                except (OpenRouterAPIError, urllib.error.URLError, urllib.error.HTTPError, json.JSONDecodeError) as e:
                    attempts += 1
                    last_error = e
                    status_code = None
                    if attempts >= OPENROUTER_MAX_RETRIES:
                        break

                    if isinstance(e, OpenRouterAPIError):
                        status_code = e.status_code
                        if status_code and status_code not in retryable_status:
                            break

                        if e.retry_after is not None and e.retry_after > 0:
                            delay = float(e.retry_after)
                        else:
                            delay = min(
                                OPENROUTER_MAX_RETRY_DELAY,
                                OPENROUTER_INITIAL_RETRY_DELAY * (2 ** (attempts - 1))
                            )
                    else:
                        delay = min(
                            OPENROUTER_MAX_RETRY_DELAY,
                            OPENROUTER_INITIAL_RETRY_DELAY * (2 ** (attempts - 1))
                        )

                    if OPENROUTER_RETRY_JITTER_SECONDS:
                        jitter = random.uniform(0.0, OPENROUTER_RETRY_JITTER_SECONDS)
                        delay += jitter

                    if delay > 0:
                        time.sleep(delay)

                    if status_code == 429:
                        app.logger.warning(
                            'OpenRouter rate-limited on attempt %s/%s; retrying in %.2fs',
                            attempts,
                            OPENROUTER_MAX_RETRIES,
                            delay,
                        )

            if last_error is not None and not response_text:
                raise last_error

            result = self._parse_openrouter_response(response_text)
            raw_selected_files = result.get('files', result.get('selected_files', []))
            normalized_files = self._normalize_selected_files(raw_selected_files)

            return {
                'success': True,
                'selected_files': normalized_files,
                'reasoning': result.get('reasoning', ''),
                'confidence': self._to_float(result.get('confidence'), 0.0)
            }
        except Exception as e:
            app.logger.error(f"OpenRouter API error: {str(e)}")
            if isinstance(e, OpenRouterAPIError):
                return {
                    'success': False,
                    'error': e.error,
                    'error_category': 'provider_error',
                    'status_code': e.status_code,
                    'error_code': e.error_code,
                    'provider': e.provider,
                    'retry_after': e.retry_after,
                    'reasoning': '',
                    'confidence': 0.0
                }
            if isinstance(e, urllib.error.HTTPError):
                return {
                    'success': False,
                    'error': str(e),
                    'error_category': 'http_error',
                    'status_code': e.code,
                    'reasoning': '',
                    'confidence': 0.0
                }

            if isinstance(e, (urllib.error.URLError, json.JSONDecodeError, ValueError)):
                return {
                    'success': False,
                    'error': str(e),
                    'error_category': 'provider_error',
                    'status_code': 503,
                    'reasoning': '',
                    'confidence': 0.0
                }

            return {
                'success': False,
                'error': str(e),
                'error_category': 'framework_error',
                'status_code': 502
            }
    
    def _build_analysis_prompt(
        self,
        query: str,
        file_structure: Dict[str, Any]
    ) -> str:
        files_info = self._extract_file_info(file_structure)
        
        prompt = f"""You are an expert code analyzer. Analyze the following project structure and identify files related to the user's query.

**User Query (in Korean):** {query}

**Project Structure:**
{json.dumps(files_info, indent=2, ensure_ascii=False)}

**Task:**
1. Understand the user's intent from the Korean query
2. Analyze each file's path, name, and extension
3. Identify files that are likely related to the query
4. Provide reasoning for each selection

**Output Format (JSON):**
{{
    "files": [
        {{
            "file_id": "unique_file_identifier",
            "relative_path": "path/to/file.ext",
            "reason": "Why this file is relevant",
            "confidence": 0.95
        }}
    ],
    "reasoning": "Overall analysis explanation in Korean",
    "confidence": 0.85
}}

**Selection Criteria:**
- File names and paths that suggest relevant functionality
- Common patterns (e.g., "upload", "download", "transfer" for file transfer)
- File types that typically contain such logic (e.g., .py, .js for backend/frontend)
- Configuration files that might define related settings

Respond ONLY with valid JSON, no additional text."""

        return prompt
    
    def _extract_file_info(self, node: Dict, files_list: Optional[List[Dict[str, Any]]] = None) -> List[Dict]:
        if files_list is None:
            files_list = []
        
        if node.get('files'):
            for file in node['files']:
                files_list.append({
                    'id': file.get('id'),
                    'relative_path': file.get('relative_path'),
                    'extension': file.get('extension'),
                    'size': file.get('size')
                })
        
        if node.get('children'):
            for child in node['children']:
                self._extract_file_info(child, files_list)
        
        return files_list

    @staticmethod
    def _safe_json_loads(payload: str) -> Optional[Dict[str, Any]]:
        try:
            loaded = json.loads(payload)
            if isinstance(loaded, dict):
                return loaded
            return None
        except Exception:
            return None

    @staticmethod
    def _extract_retry_after_from_message(message: str) -> Optional[float]:
        if not message:
            return None

        message_lower = message.lower()
        if 'retry' not in message_lower:
            return None

        patterns = [
            r'please\s+retry\s+in\s*([0-9]+(?:\.[0-9]+)?)\s*s',
            r'retry\s+in\s*([0-9]+(?:\.[0-9]+)?)\s*seconds?',
            r'retry\s+in\s*([0-9]+(?:\.[0-9]+)?)\s*sec'
        ]

        for pattern in patterns:
            match = re.search(pattern, message_lower)
            if match is None:
                continue
            try:
                return float(match.group(1))
            except ValueError:
                return None

        return None

    def _extract_retry_after(
        self,
        parsed_error: Optional[Dict[str, Any]],
        headers: Optional[Any],
        error_body: str
    ) -> Optional[float]:
        retry_after: Optional[float] = None
        raw_retry = None

        if headers is not None and hasattr(headers, 'get'):
            raw_retry = headers.get('Retry-After')
        if isinstance(raw_retry, str):
            raw_retry = raw_retry.strip()
            if raw_retry.isdigit():
                try:
                    return float(int(raw_retry))
                except ValueError:
                    raw_retry = None
            elif raw_retry:
                try:
                    retry_datetime = datetime.strptime(raw_retry, '%a, %d %b %Y %H:%M:%S GMT')
                    retry_after = (retry_datetime - datetime.utcnow()).total_seconds()
                except Exception:
                    retry_after = None
                if retry_after is not None and retry_after > 0:
                    return retry_after

        if parsed_error is not None:
            error_info = parsed_error.get('error')
            if isinstance(error_info, dict):
                provider_retry = error_info.get('retryDelay')
                if isinstance(provider_retry, (int, float)):
                    return float(provider_retry)
                if isinstance(provider_retry, str):
                    try:
                        return float(provider_retry)
                    except ValueError:
                        pass

                metadata = error_info.get('metadata')
                if isinstance(metadata, dict):
                    retry_value = metadata.get('retryAfter') or metadata.get('retry_after')
                    if isinstance(retry_value, (int, float)):
                        return float(retry_value)
                    if isinstance(retry_value, str):
                        try:
                            return float(retry_value)
                        except ValueError:
                            pass

                raw_metadata = metadata.get('raw') if isinstance(metadata, dict) else None
                raw_object = self._safe_json_loads(raw_metadata) if isinstance(raw_metadata, str) else None
                if isinstance(raw_object, dict):
                    raw_error = raw_object.get('error') if isinstance(raw_object.get('error'), dict) else None
                    if isinstance(raw_error, dict):
                        retry_delay = raw_error.get('retryDelay')
                        if isinstance(retry_delay, (int, float)):
                            return float(retry_delay)
                        if isinstance(retry_delay, str):
                            try:
                                return float(retry_delay)
                            except ValueError:
                                pass

                        raw_message = raw_error.get('message')
                        if isinstance(raw_message, str):
                            parsed_retry = self._extract_retry_after_from_message(raw_message)
                            if parsed_retry is not None:
                                return parsed_retry

                message = error_info.get('message')
                parsed_retry = self._extract_retry_after_from_message(
                    message if isinstance(message, str) else ''
                )
                if parsed_retry is not None:
                    return parsed_retry

        body_error = self._safe_json_loads(error_body)
        if isinstance(body_error, dict):
            outer_error = body_error.get('error')
            if isinstance(outer_error, dict):
                outer_message = outer_error.get('message')
                if not isinstance(outer_message, str):
                    outer_message = ''

                parsed_retry = self._extract_retry_after_from_message(outer_message)
                if parsed_retry is not None:
                    return parsed_retry

        return None

    @staticmethod
    def _extract_provider_error_info(parsed_error: Optional[Dict[str, Any]]) -> Tuple[Optional[str], str, Optional[Any]]:
        if parsed_error is None:
            return None, '', None

        error_info = parsed_error.get('error')
        if not isinstance(error_info, dict):
            return None, str(error_info) if error_info else '', None

        provider_name = error_info.get('provider_name')
        if isinstance(provider_name, str):
            provider_name = provider_name.strip()
        if provider_name is None and isinstance(error_info.get('metadata'), dict):
            provider_name = error_info['metadata'].get('provider_name')
            if isinstance(provider_name, str):
                provider_name = provider_name.strip()

        error_message = error_info.get('message')
        if not isinstance(error_message, str):
            error_message = ''

        error_code = error_info.get('code')
        if error_code is None:
            error_code = error_info.get('status')

        return provider_name, error_message, error_code

    @staticmethod
    def _parse_openrouter_error_payload(error_body: str) -> Optional[Dict[str, Any]]:
        parsed_error = OpenRouterFileAnalyzer._safe_json_loads(error_body)
        if parsed_error is not None:
            return parsed_error

        cleaned_body = error_body.strip()
        if cleaned_body.startswith('```json'):
            cleaned_body = cleaned_body[7:]
        if cleaned_body.startswith('```'):
            cleaned_body = cleaned_body[3:]
        if cleaned_body.endswith('```'):
            cleaned_body = cleaned_body[:-3]

        parsed_error = OpenRouterFileAnalyzer._safe_json_loads(cleaned_body.strip())
        if parsed_error is not None:
            return parsed_error

        match = re.search(r'\{.*\}', error_body, flags=re.DOTALL)
        if match:
            parsed_error = OpenRouterFileAnalyzer._safe_json_loads(match.group(0))
            if parsed_error is not None:
                return parsed_error

        return None
    
    def _parse_openrouter_response(self, response_text: str) -> Dict:
        try:
            cleaned_text = response_text.strip()
            if not cleaned_text:
                app.logger.warning('OpenRouter response body was empty')
                return {
                    'files': [],
                    'reasoning': 'No response content',
                    'confidence': 0.0
                }
            
            if cleaned_text.startswith('```json'):
                cleaned_text = cleaned_text[7:]
            if cleaned_text.startswith('```'):
                cleaned_text = cleaned_text[3:]
            if cleaned_text.endswith('```'):
                cleaned_text = cleaned_text[:-3]
            
            cleaned_text = cleaned_text.strip()

            try:
                result = json.loads(cleaned_text)
            except json.JSONDecodeError:
                match = re.search(r'\{.*\}', cleaned_text, flags=re.DOTALL)
                if not match:
                    raise
                result = json.loads(match.group(0))
            return result
        except json.JSONDecodeError as e:
            app.logger.error(f"JSON parsing error: {e}\nResponse: {response_text}")
            return {
                'files': [],
                'reasoning': 'Failed to parse AI response',
                'confidence': 0.0
            }

    @staticmethod
    def _to_float(value: Any, default: float = 0.0) -> float:
        try:
            return float(value)
        except (TypeError, ValueError):
            return default

    def _normalize_selected_files(self, selected_files: Any) -> List[Dict[str, Any]]:
        normalized = []

        if not isinstance(selected_files, list):
            app.logger.warning(
                f'OpenRouter selected files payload is not a list: {type(selected_files).__name__}'
            )
            return normalized

        for entry in selected_files:
            if not isinstance(entry, dict):
                app.logger.warning(f'Ignoring invalid selected entry: {entry}')
                continue

            normalized.append({
                'file_id': entry.get('file_id') or entry.get('id') or entry.get('fileId'),
                'relative_path': entry.get('relative_path') or entry.get('path'),
                'reason': entry.get('reason', ''),
                'confidence': self._to_float(entry.get('confidence'), 0.0)
            })

        return normalized

def cleanup_old_sessions():
    while True:
        try:
            now = datetime.now()
            for file in TEMP_DIR.glob("*"):
                if file.is_file():
                    file_age = now - datetime.fromtimestamp(file.stat().st_mtime)
                    if file_age > SESSION_TIMEOUT:
                        file.unlink()
            
            for file in ORIGINALS_DIR.glob("*"):
                if file.is_file():
                    file_age = now - datetime.fromtimestamp(file.stat().st_mtime)
                    if file_age > SESSION_TIMEOUT:
                        file.unlink()
        except Exception as e:
            app.logger.error(f"Cleanup error: {e}")
        
        time.sleep(3600)

cleanup_thread = threading.Thread(target=cleanup_old_sessions, daemon=True)
cleanup_thread.start()

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/api/analyze', methods=['POST'])
def analyze_directory():
    data = request.json
    directory = data.get('directory', '.')
    
    directory = os.path.abspath(directory)
    
    if not os.path.exists(directory):
        return jsonify({'error': f'Directory not found: {directory}'}), 404
    
    try:
        aggregator = WebSourceAggregator(directory)
        result = aggregator.analyze_directory_structure()
        
        session['root_dir'] = directory
        session['analysis_id'] = secrets.token_hex(8)
        
        analysis_file = TEMP_DIR / f"{session['analysis_id']}_analysis.json"
        with open(analysis_file, 'w', encoding='utf-8') as f:
            json.dump({
                'root_dir': directory,
                'all_files': aggregator.all_files,
                'all_directories': aggregator.all_directories,
                'file_extensions': dict(aggregator.file_extensions),
                'search_index': aggregator.search_index
            }, f, ensure_ascii=False)
        
        return jsonify(result)
    except Exception as e:
        app.logger.error(f"Analysis error: {e}")
        import traceback
        traceback.print_exc()
        return jsonify({'error': str(e)}), 500

@app.route('/api/search', methods=['POST'])
def search_files():
    data = request.json
    query = data.get('query', '')
    
    if not query:
        return jsonify({'results': []})
    
    try:
        analysis_id = session.get('analysis_id')
        if not analysis_id:
            return jsonify({'error': 'No analysis found'}), 400
        
        analysis_file = TEMP_DIR / f"{analysis_id}_analysis.json"
        if not analysis_file.exists():
            return jsonify({'error': 'Analysis data not found'}), 404
        
        with open(analysis_file, 'r', encoding='utf-8') as f:
            analysis_data = json.load(f)
        
        aggregator = WebSourceAggregator(analysis_data['root_dir'])
        aggregator.all_files = analysis_data['all_files']
        aggregator.search_index = analysis_data['search_index']
        
        results = aggregator.search_files(query)
        
        return jsonify({'results': results[:50]})
    except Exception as e:
        app.logger.error(f"Search error: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/select-by-names', methods=['POST'])
def select_by_names():
    data = request.json
    filenames = data.get('filenames', [])
    
    if not filenames:
        return jsonify({'error': 'No filenames provided'}), 400
    
    try:
        analysis_id = session.get('analysis_id')
        if not analysis_id:
            return jsonify({'error': 'No analysis found'}), 400
        
        analysis_file = TEMP_DIR / f"{analysis_id}_analysis.json"
        if not analysis_file.exists():
            return jsonify({'error': 'Analysis data not found'}), 404
        
        with open(analysis_file, 'r', encoding='utf-8') as f:
            analysis_data = json.load(f)
        
        aggregator = WebSourceAggregator(analysis_data['root_dir'])
        aggregator.all_files = analysis_data['all_files']
        
        result = aggregator.select_files_by_names(filenames)
        
        return jsonify(result)
    except Exception as e:
        app.logger.error(f"Select by names error: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/generate', methods=['POST'])
def generate_markdown():
    data = request.json
    selected_files = data.get('files', [])
    compression_type = data.get('compression_type', 'none')
    
    if not selected_files:
        return jsonify({'error': 'No files selected'}), 400
    
    if compression_type not in ['none', 'semantic', 'lossless', 'hybrid', 'signatures', 'smart', 'descriptive']:
        return jsonify({'error': 'Invalid compression type'}), 400
    
    try:
        analysis_id = session.get('analysis_id')
        if not analysis_id:
            return jsonify({'error': 'No analysis found'}), 400
        
        analysis_file = TEMP_DIR / f"{analysis_id}_analysis.json"
        if not analysis_file.exists():
            return jsonify({'error': 'Analysis data not found'}), 404
        
        with open(analysis_file, 'r', encoding='utf-8') as f:
            analysis_data = json.load(f)
        
        aggregator = WebSourceAggregator(analysis_data['root_dir'])
        aggregator.all_files = analysis_data['all_files']
        aggregator.all_directories = analysis_data['all_directories']
        
        markdown_content, compression_info = aggregator.generate_markdown(
            selected_files,
            compression_type
        )
        
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        if compression_type == 'none':
            extension = 'md'
        else:
            extension = 'json'

        requested_filename = data.get('filename')
        sanitized_filename = sanitize_output_filename(requested_filename, compression_type)
        default_filename = f"source_code_{compression_type}_{timestamp}.{extension}"
        output_filename = sanitized_filename or default_filename
        output_file = TEMP_DIR / output_filename
        
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write(markdown_content)
        
        response_data = {
            'success': True,
            'filename': output_file.name,
            'size': len(markdown_content),
            'file_count': len(selected_files),
            'compression_type': compression_type
        }
        
        if compression_info and 'metadata' in compression_info:
            response_data['compression_info'] = compression_info['metadata']
        
        return jsonify(response_data)
    except Exception as e:
        app.logger.error(f"Generate error: {e}")
        import traceback
        traceback.print_exc()
        return jsonify({'error': str(e)}), 500

@app.route('/api/download/<filename>')
def download_file(filename):
    file_path = TEMP_DIR / filename
    
    if not file_path.exists():
        return jsonify({'error': 'File not found'}), 404
    
    if filename.endswith('.json'):
        mimetype = 'application/json'
    else:
        mimetype = 'text/markdown'
    
    return send_file(
        file_path,
        as_attachment=True,
        download_name=filename,
        mimetype=mimetype
    )

@app.route('/api/preview', methods=['POST'])
def preview_file():
    data = request.json
    file_path = data.get('path')
    
    if not file_path or not os.path.exists(file_path):
        return jsonify({'error': 'File not found'}), 404
    
    try:
        file_path = Path(file_path)
        
        if file_path.stat().st_size > 1024 * 1024:
            return jsonify({'error': 'File too large for preview'}), 413
        
        with open(file_path, 'rb') as f:
            raw_data = f.read(1000)
            result = chardet.detect(raw_data)
            encoding = result.get('encoding', 'utf-8')
        
        with open(file_path, 'r', encoding=encoding, errors='replace') as f:
            content = f.read(5000)
            if len(content) == 5000:
                content += "\n\n... (truncated)"
        
        return jsonify({
            'content': content,
            'encoding': encoding
        })
    except Exception as e:
        app.logger.error(f"Preview error: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/decompress', methods=['POST'])
def decompress_file():
    data = request.json
    compressed_data = data.get('data')
    
    if not compressed_data:
        return jsonify({'error': 'No compressed data provided'}), 400
    
    try:
        compression_type = compressed_data.get('metadata', {}).get('compression_type')
        
        if compression_type == 'gzip_lossless':
            compressor = LosslessCompressor()
            original_content = compressor.decompress_markdown(compressed_data)
            
            return jsonify({
                'success': True,
                'content': original_content,
                'size': len(original_content)
            })
        elif compression_type == 'hybrid':
            compressor = HybridCompressor()
            original_content = compressor.get_original_content(
                compressed_data['original_reference'],
                compressed_data
            )
            
            if not original_content:
                return jsonify({'error': 'Original file not found'}), 404
            
            return jsonify({
                'success': True,
                'content': original_content,
                'size': len(original_content)
            })
        else:
            return jsonify({'error': 'Cannot decompress semantic compression'}), 400
    except Exception as e:
        app.logger.error(f"Decompress error: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/ai-select', methods=['POST'])
def ai_select_files():
    data = request.get_json(silent=True) or {}
    if not isinstance(data, dict):
        return jsonify({
            'success': False,
            'error': 'Invalid request body',
            'error_category': 'framework_error',
            'status_code': 400,
            'reasoning': '',
            'confidence': 0.0
        }), 400

    query = data.get('query', '')
    if not isinstance(query, str):
        query = ''
    query = query.strip()

    if not query:
        return jsonify({
            'success': False,
            'error': 'Query is required',
            'error_category': 'framework_error',
            'status_code': 400,
            'reasoning': '',
            'confidence': 0.0
        }), 400

    try:
        analysis_id = session.get('analysis_id')
        if not analysis_id:
            return jsonify({
                'success': False,
                'error': 'No analysis found. Please analyze directory first.',
                'error_category': 'framework_error',
                'status_code': 400,
                'reasoning': '',
                'confidence': 0.0
            }), 400

        analysis_file = TEMP_DIR / f"{analysis_id}_analysis.json"
        if not analysis_file.exists():
            return jsonify({
                'success': False,
                'error': 'Analysis data not found',
                'error_category': 'framework_error',
                'status_code': 404,
                'reasoning': '',
                'confidence': 0.0
            }), 404

        with open(analysis_file, 'r', encoding='utf-8') as f:
            analysis_data = json.load(f)

        all_files = analysis_data.get('all_files', {})
        if not isinstance(all_files, dict):
            return jsonify({
                'success': False,
                'error': 'Invalid analysis data',
                'error_category': 'framework_error',
                'status_code': 500,
                'reasoning': 'Stored analysis data is invalid.',
                'confidence': 0.0
            }), 500

        known_filenames = {
            Path(file_info['relative_path']).name.lower()
            for file_info in all_files.values()
            if isinstance(file_info, dict) and isinstance(file_info.get('relative_path'), str)
        }
        known_extensions = {
            Path(file_info['relative_path']).suffix.lower()
            for file_info in all_files.values()
            if isinstance(file_info, dict)
            and isinstance(file_info.get('relative_path'), str)
            and Path(file_info['relative_path']).suffix
        }

        filename_candidates = _extract_filename_only_candidates(
            query,
            known_filenames=known_filenames,
            known_extensions=known_extensions
        )

        if filename_candidates:
            aggregator = WebSourceAggregator(analysis_data['root_dir'])
            aggregator.all_files = all_files
            filename_result = aggregator.select_files_by_names(filename_candidates)
            is_pure_filename_query = _is_pure_filename_query(query, filename_candidates)

            selected_ids = filename_result.get('selected', [])
            file_details = []
            added_file_ids = set()

            for file_id in selected_ids:
                if file_id in added_file_ids:
                    continue
                file_info = all_files.get(file_id)
                if not isinstance(file_info, dict):
                    continue

                relative_path = file_info.get('relative_path')
                if not isinstance(relative_path, str):
                    continue

                file_details.append({
                    'file_id': file_id,
                    'relative_path': relative_path,
                    'reason': 'Matched by filename only',
                    'confidence': 1.0
                })
                added_file_ids.add(file_id)

            if selected_ids and is_pure_filename_query:
                selected_file_ids = [
                    detail['file_id'] for detail in file_details
                ]
                return jsonify({
                    'success': True,
                    'selected_files': selected_file_ids,
                    'file_details': file_details,
                    'reasoning': (
                        f"Used filename-only matching for query: {', '.join(filename_candidates)}"
                    ),
                    'confidence': 1.0,
                    'total_selected': len(file_details)
                })

            if is_pure_filename_query:
                return jsonify({
                    'success': False,
                    'error': (
                        '요청하신 파일명을 기반으로 찾는 과정에서 일치하는 파일이 없습니다. '
                        '원하면 경로 또는 파일명을 더 정확히 입력해 주세요.'
                    ),
                    'error_category': 'framework_error',
                    'status_code': 422,
                    'error_code': 'no_filename_match',
                    'reasoning': (
                        'Filename-only query did not match any files in the current project.'
                    ),
                    'confidence': 0.0,
                    'file_details': []
                }), 422

        file_manifest = _build_ai_file_manifest(
            analysis_data['all_files'],
            query,
            max_files=AI_SELECT_MAX_FILES_FOR_PROMPT
        )

        tree_structure = {
            'files': file_manifest
        }

        analyzer = OpenRouterFileAnalyzer()
        result = analyzer.analyze_files_for_query(query, tree_structure)

        if not result['success']:
            status_code = result.get('status_code', 502)
            error_category = result.get('error_category', 'framework_error')
            if status_code == 429:
                response_status = 429
            elif status_code in [500, 502, 503, 504]:
                response_status = 503
            else:
                response_status = 502

            base_error = result.get('error', 'AI analysis failed')
            error_message = str(base_error)

            if status_code == 429:
                retry_after = result.get('retry_after')
                retry_text = ''
                if retry_after is not None:
                    try:
                        retry_seconds = max(1, int(float(retry_after)))
                        retry_text = f' {retry_seconds}초 뒤에 다시 시도해 주세요.'
                    except (TypeError, ValueError):
                        retry_text = ' 잠시 후 다시 시도해 주세요.'
                else:
                    retry_text = ' 잠시 후 다시 시도해 주세요.'

                error_message = (
                    '쿼터/속도 제한으로 AI 요청이 일시 중단되었습니다.'
                    f'{retry_text}'
                )

            elif error_category == 'provider_error':
                error_message = f'외부 AI API 오류: {base_error}'

            elif error_category in ['http_error', 'framework_error']:
                error_message = (
                    'AI 분석 처리 중 임시 오류가 발생했습니다. '
                    f'잠시 후 다시 시도해 주세요. ({base_error})'
                )

            error_payload = {
                'success': False,
                'error': error_message,
                'status_code': status_code,
                'error_category': error_category,
                'error_code': result.get('error_code'),
                'provider': result.get('provider'),
                'retry_after': result.get('retry_after'),
                'reasoning': result.get('reasoning', '')
            }

            return jsonify(error_payload), response_status

        valid_selections: List[str] = []
        file_details: List[Dict[str, Any]] = []

        for file_entry in result.get('selected_files', []):
            if not isinstance(file_entry, dict):
                continue

            file_id = file_entry.get('file_id')
            relative_path = file_entry.get('relative_path')

            if file_id and file_id in analysis_data['all_files']:
                valid_selections.append(file_id)
                file_details.append(file_entry)
                continue

            if relative_path:
                fallback_file_id = next(
                    (
                        candidate_id
                        for candidate_id, file_info in analysis_data['all_files'].items()
                        if file_info.get('relative_path') == relative_path
                    ),
                    None
                )
                if fallback_file_id:
                    valid_selections.append(fallback_file_id)
                    file_details.append({
                        **file_entry,
                        'file_id': fallback_file_id
                    })

        if not valid_selections:
            return jsonify({
                'success': False,
                'error': 'AI 분석 결과에서 일치하는 파일을 찾지 못했습니다.',
                'error_category': 'framework_error',
                'status_code': 422,
                'error_code': 'no_match',
                'reasoning': result.get('reasoning', ''),
                'confidence': result.get('confidence', 0.0),
                'file_details': []
            }), 422

        unique_selected: List[str] = []
        seen = set()
        for file_id in valid_selections:
            if file_id in seen:
                continue
            seen.add(file_id)
            unique_selected.append(file_id)

        unique_file_details: List[Dict[str, Any]] = []
        seen_details = set()
        for file_entry in file_details:
            detail_file_id = file_entry.get('file_id')
            if not detail_file_id or detail_file_id in seen_details:
                continue
            seen_details.add(detail_file_id)
            unique_file_details.append(file_entry)

        filtered_details = [
            file_entry
            for file_entry in unique_file_details
            if file_entry.get('file_id') in unique_selected
        ]

        return jsonify({
            'success': True,
            'selected_files': unique_selected,
            'file_details': filtered_details,
            'reasoning': result['reasoning'],
            'confidence': result['confidence'],
            'total_selected': len(unique_selected)
        })

    except Exception as e:
        app.logger.error(f"AI selection error: {e}")
        import traceback
        traceback.print_exc()
        return jsonify({
            'success': False,
            'error': str(e),
            'error_category': 'framework_error',
            'status_code': 500,
            'reasoning': '',
            'confidence': 0.0
        }), 500

@app.route('/api/analyze-dependencies', methods=['POST'])
def analyze_dependencies():
    data = request.json
    selected_files = data.get('files', [])
    
    if not selected_files:
        return jsonify({'error': 'No files selected'}), 400
    
    try:
        analysis_id = session.get('analysis_id')
        if not analysis_id:
            return jsonify({'error': 'No analysis found'}), 400
        
        analysis_file = TEMP_DIR / f"{analysis_id}_analysis.json"
        if not analysis_file.exists():
            return jsonify({'error': 'Analysis data not found'}), 404
        
        with open(analysis_file, 'r', encoding='utf-8') as f:
            analysis_data = json.load(f)
        
        analyzer = DependencyAnalyzer(
            analysis_data['all_files'],
            analysis_data['root_dir']
        )
        
        result = analyzer.analyze_dependencies(selected_files)
        
        dep_file = TEMP_DIR / f"{analysis_id}_dependencies.json"
        with open(dep_file, 'w', encoding='utf-8') as f:
            json.dump(result, f, ensure_ascii=False)
        
        return jsonify({
            'success': True,
            'analysis': result
        })
    
    except Exception as e:
        app.logger.error(f"Dependency analysis error: {e}")
        import traceback
        traceback.print_exc()
        return jsonify({'error': str(e)}), 500

@app.route('/api/add-missing-dependencies', methods=['POST'])
def add_missing_dependencies():
    data = request.json
    missing_file_ids = data.get('file_ids', [])
    
    if not missing_file_ids:
        return jsonify({'error': 'No file IDs provided'}), 400
    
    try:
        analysis_id = session.get('analysis_id')
        if not analysis_id:
            return jsonify({'error': 'No analysis found'}), 400
        
        analysis_file = TEMP_DIR / f"{analysis_id}_analysis.json"
        if not analysis_file.exists():
            return jsonify({'error': 'Analysis data not found'}), 404
        
        with open(analysis_file, 'r', encoding='utf-8') as f:
            analysis_data = json.load(f)
        
        valid_files = []
        for file_id in missing_file_ids:
            if file_id in analysis_data['all_files']:
                valid_files.append(file_id)
        
        return jsonify({
            'success': True,
            'added_files': valid_files,
            'count': len(valid_files)
        })
    
    except Exception as e:
        app.logger.error(f"Add dependencies error: {e}")
        return jsonify({'error': str(e)}), 500




if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)