"""Gradio UI for Legacy Code Modernizer Agent - Phase 5 Complete."""
import gradio as gr
import os
import asyncio
import logging
import zipfile
import tempfile
from dotenv import load_dotenv
from pathlib import Path
# Import orchestrator
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
from src.workflow.orchestrator import ModernizationOrchestrator
# Load environment variables
load_dotenv()
# Configure logging with sensitive data redaction
class SensitiveDataFilter(logging.Filter):
"""Filter to redact sensitive information from logs."""
def __init__(self):
super().__init__()
self.sensitive_patterns = []
# Collect sensitive values from environment
sensitive_keys = [
"GEMINI_API_KEY",
"NEBIUS_API_KEY",
"OPENAI_API_KEY",
"MODAL_TOKEN_ID",
"MODAL_TOKEN_SECRET",
"GITHUB_TOKEN"
]
for key in sensitive_keys:
value = os.getenv(key)
if value and len(value) > 5: # Only redact if value is substantial
self.sensitive_patterns.append(value)
def filter(self, record):
msg = str(record.msg)
for sensitive_value in self.sensitive_patterns:
if sensitive_value in msg:
msg = msg.replace(sensitive_value, "[REDACTED]")
record.msg = msg
return True
# Initialize logging with redaction
logging.basicConfig(level=logging.INFO)
root_logger = logging.getLogger()
root_logger.addFilter(SensitiveDataFilter())
logger = logging.getLogger(__name__)
# Initialize orchestrator with intelligent pattern matching
orchestrator = ModernizationOrchestrator(use_intelligent_matcher=True)
# Supported file extensions for single file upload
SUPPORTED_EXTENSIONS = {
# Python
'.py', '.pyw', '.pyx',
# Java
'.java',
# JavaScript/TypeScript
'.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'
}
# Language to file extension mapping
LANGUAGE_EXTENSIONS = {
'python': ['.py', '.pyw', '.pyx'],
'java': ['.java'],
'javascript': ['.js', '.jsx', '.mjs', '.cjs'],
'typescript': ['.ts', '.tsx']
}
# Target version options for each language (Updated November 2025)
TARGET_VERSIONS = {
'python': ['Python 3.14', 'Python 3.13', 'Python 3.12', 'Python 3.11', 'Python 3.10'],
'java': ['Java 25 LTS', 'Java 23', 'Java 21 LTS', 'Java 17 LTS'],
'javascript': ['ES2025', 'ES2024', 'Node.js 25', 'Node.js 24 LTS', 'Node.js 22 LTS'],
'typescript': ['TypeScript 5.9', 'TypeScript 5.8', 'TypeScript 5.7', 'TypeScript 5.6']
}
# Framework-specific versions (Updated November 2025)
FRAMEWORK_VERSIONS = [
'React 19', 'React 18', 'React 18 (Hooks)', 'React 17',
'Angular 21', 'Angular 20', 'Angular 19',
'Vue 3.5', 'Vue 3.4', 'Vue 2.7',
'Django 5.2 LTS', 'Django 5.1', 'Django 5.0',
'Flask 3.1', 'Flask 3.0', 'Flask 2.3',
'Spring Boot 4.0', 'Spring Boot 3.4', 'Spring Boot 3.3',
'Laravel 12', 'Laravel 11',
'Rails 8.1', 'Rails 8.0', 'Rails 7.2',
'Express 5.1', 'Express 5.0', 'Express 4.21',
'FastAPI 0.122', 'FastAPI 0.115',
'Next.js 16', 'Next.js 15', 'Next.js 14'
]
def detect_language_from_extension(file_ext):
"""Detect language from file extension."""
for lang, exts in LANGUAGE_EXTENSIONS.items():
if file_ext in exts:
return lang
return None
def get_target_versions_for_language(language):
"""Get appropriate target versions for a detected language."""
if not language:
# Return all options if language unknown
all_versions = []
for versions in TARGET_VERSIONS.values():
all_versions.extend(versions)
all_versions.extend(FRAMEWORK_VERSIONS)
return sorted(set(all_versions))
# Get language-specific versions
versions = TARGET_VERSIONS.get(language, [])
# Add framework versions for web languages
if language in ['javascript', 'typescript']:
versions.extend([v for v in FRAMEWORK_VERSIONS if 'React' in v or 'Angular' in v or 'Vue' in v or 'Express' in v])
elif language == 'python':
versions.extend([v for v in FRAMEWORK_VERSIONS if 'Django' in v or 'Flask' in v or 'FastAPI' in v])
elif language == 'java':
versions.extend([v for v in FRAMEWORK_VERSIONS if 'Spring' in v])
elif language == 'php':
versions.extend([v for v in FRAMEWORK_VERSIONS if 'Laravel' in v])
elif language == 'ruby':
versions.extend([v for v in FRAMEWORK_VERSIONS if 'Rails' in v])
return versions if versions else get_target_versions_for_language(None)
def detect_languages_from_files(file_paths):
"""
Detect languages from multiple files.
Args:
file_paths: List of file paths
Returns:
Dictionary with language counts and suggested target versions
"""
language_counts = {}
for file_path in file_paths:
ext = Path(file_path).suffix.lower()
lang = detect_language_from_extension(ext)
if lang:
language_counts[lang] = language_counts.get(lang, 0) + 1
if not language_counts:
return None, []
# Get primary language (most files)
primary_language = max(language_counts.items(), key=lambda x: x[1])[0]
# Get suggested versions
suggested_versions = get_target_versions_for_language(primary_language)
return primary_language, suggested_versions
def validate_single_file(file_path):
"""
Validate if a single file is supported for modernization.
Args:
file_path: Path to the uploaded file
Returns:
Tuple of (is_valid, message, file_info, suggested_versions)
"""
if not file_path:
return False, "❌ No file uploaded", None, []
try:
file_name = Path(file_path).name
file_ext = Path(file_path).suffix.lower()
file_size = os.path.getsize(file_path)
# Check file extension
if file_ext not in SUPPORTED_EXTENSIONS:
supported_list = ', '.join(sorted(SUPPORTED_EXTENSIONS))
return False, f"❌ Unsupported file type: {file_ext}\n\n✅ Supported types:\n{supported_list}", None, []
# Check file size (max 10MB for single file)
max_size = 10 * 1024 * 1024 # 10MB
if file_size > max_size:
return False, f"❌ File too large: {file_size / 1024 / 1024:.2f} MB (max 10 MB)", None, []
# Read file to check if it's valid text
try:
with open(file_path, 'r', encoding='utf-8') as f:
content = f.read(1000) # Read first 1000 chars
line_count = len(content.split('\n'))
except UnicodeDecodeError:
return False, f"❌ File is not a valid text file (encoding error)", None, []
# Detect language and get suggested versions
language = detect_language_from_extension(file_ext)
suggested_versions = get_target_versions_for_language(language)
# Language name mapping
language_names = {
'python': 'Python',
'java': 'Java',
'javascript': 'JavaScript',
'typescript': 'TypeScript'
}
file_info = {
'name': file_name,
'extension': file_ext,
'size': file_size,
'path': file_path,
'language': language
}
lang_display = language_names.get(language, 'Unknown')
message = f"""✅ File validated successfully!
📄 File: {file_name}
📊 Type: {file_ext} ({lang_display})
💾 Size: {file_size / 1024:.2f} KB
🎯 Suggested target versions updated in dropdown
✨ Ready to modernize! Click 'Start Modernization' button."""
return True, message, file_info, suggested_versions
except Exception as e:
return False, f"❌ Error validating file: {str(e)}", None, []
def process_single_file(file_path):
"""
Process single file upload by creating a temporary ZIP.
Args:
file_path: Path to the uploaded file
Returns:
Tuple of (status message, zip path, suggested_versions)
"""
is_valid, message, file_info, suggested_versions = validate_single_file(file_path)
if not is_valid:
return message, None, []
try:
# Create a temporary ZIP containing the single file
import tempfile
import zipfile
zip_path = tempfile.NamedTemporaryFile(delete=False, suffix='.zip')
with zipfile.ZipFile(zip_path.name, 'w', zipfile.ZIP_DEFLATED) as zipf:
zipf.write(file_path, file_info['name'])
return message, zip_path.name, suggested_versions
except Exception as e:
return f"❌ Error processing file: {str(e)}", None, []
def detect_languages_from_zip(zip_path):
"""
Detect languages from files in a ZIP archive.
Args:
zip_path: Path to ZIP file
Returns:
Tuple of (language_summary, suggested_versions)
"""
try:
import zipfile
file_paths = []
with zipfile.ZipFile(zip_path, 'r') as zipf:
file_paths = [name for name in zipf.namelist() if not name.endswith('/')]
primary_language, suggested_versions = detect_languages_from_files(file_paths)
if not primary_language:
return "Multiple file types detected", []
language_names = {
'python': 'Python',
'java': 'Java',
'javascript': 'JavaScript',
'typescript': 'TypeScript'
}
return f"Primary language: {language_names.get(primary_language, 'Unknown')}", suggested_versions
except Exception as e:
logger.error(f"Error detecting languages from ZIP: {e}")
return "Could not detect language", []
def clone_github_repo(github_url):
"""
Clone GitHub repository and show preview.
Args:
github_url: GitHub repository URL
Returns:
Tuple of (status message, cloned repo path)
"""
if not github_url or not github_url.strip():
return "❌ Please enter a GitHub repository URL", None, gr.update(visible=True)
try:
import tempfile
import subprocess
# Clean URL (remove .git if present)
github_url = github_url.strip().rstrip('/')
if github_url.endswith('.git'):
github_url = github_url[:-4]
# Create temp directory for clone
temp_dir = tempfile.mkdtemp(prefix="github_clone_")
# Clone repository
result = subprocess.run(
["git", "clone", "--depth", "1", github_url, temp_dir],
capture_output=True,
text=True,
timeout=300
)
if result.returncode != 0:
error_msg = result.stderr if result.stderr else "Unknown error"
return f"❌ Failed to clone repository:\n{error_msg}", None, gr.update(visible=True)
# Count files (only supported extensions)
code_extensions = {'.py', '.pyw', '.pyx', '.java', '.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'}
file_count = 0
code_files = []
for root, dirs, files in os.walk(temp_dir):
# Skip .git directory
if '.git' in root:
continue
for file in files:
file_path = os.path.join(root, file)
rel_path = os.path.relpath(file_path, temp_dir)
ext = os.path.splitext(file)[1].lower()
if ext in code_extensions:
file_count += 1
code_files.append(rel_path)
# Create ZIP from cloned repo
import zipfile
zip_path = tempfile.NamedTemporaryFile(delete=False, suffix='.zip')
with zipfile.ZipFile(zip_path.name, 'w', zipfile.ZIP_DEFLATED) as zipf:
for root, dirs, files in os.walk(temp_dir):
# Skip .git directory
if '.git' in root:
continue
for file in files:
file_path = os.path.join(root, file)
arcname = os.path.relpath(file_path, temp_dir)
zipf.write(file_path, arcname)
# Detect languages
all_code_files = []
for root, dirs, files in os.walk(temp_dir):
if '.git' in root:
continue
for file in files:
ext = os.path.splitext(file)[1].lower()
if ext in SUPPORTED_EXTENSIONS:
all_code_files.append(os.path.join(root, file))
primary_language, suggested_versions = detect_languages_from_files(all_code_files)
language_names = {
'python': 'Python',
'java': 'Java',
'javascript': 'JavaScript',
'typescript': 'TypeScript'
}
# Generate preview message with all files
status = f"""✅ Repository cloned successfully!
📁 Repository: {github_url.split('/')[-1]}
📊 Code files found: {file_count}
🔤 Primary language: {language_names.get(primary_language, 'Mixed')}
📝 Loaded files ({file_count} total):
"""
# Show all files, not just first 15
for f in code_files:
status += f" • {f}\n"
status += "\n🎯 Suggested target versions updated in dropdown"
status += "\n✨ Ready to modernize! Click 'Start Modernization' button above."
return status, zip_path.name, gr.update(visible=True), suggested_versions
except subprocess.TimeoutExpired:
return "❌ Clone timeout (>5 minutes). Repository might be too large.", None, gr.update(visible=True)
except Exception as e:
return f"❌ Error cloning from GitHub: {str(e)}", None, gr.update(visible=True)
def modernize_code(repo_file, target_version, create_pr, repo_url, github_token, cloned_repo_path, single_file_path, progress=gr.Progress()):
"""
Main function to process uploaded repository.
Args:
repo_file: Uploaded ZIP file containing the repository
target_version: Target language/framework version
create_pr: Whether to create GitHub PR
repo_url: GitHub repository URL for PR
github_token: GitHub personal access token for PR creation
cloned_repo_path: Path to cloned repo ZIP (if using GitHub clone)
single_file_path: Path to single file ZIP (if using single file upload)
progress: Gradio progress tracker
Returns:
Tuple of (status message, download files)
"""
logger.info(f"modernize_code called with: repo_file={repo_file}, single_file_path={single_file_path}, cloned_repo_path={cloned_repo_path}")
# Priority: single file > cloned repo > uploaded file
if single_file_path:
logger.info(f"Single file path detected: {single_file_path}")
repo_file = type('obj', (object,), {'name': single_file_path})()
logger.info(f"Using single file path: {single_file_path}")
elif cloned_repo_path:
logger.info(f"Cloned repo path detected: {cloned_repo_path}")
repo_file = type('obj', (object,), {'name': cloned_repo_path})()
logger.info(f"Using cloned repo path: {cloned_repo_path}")
else:
logger.info("Using uploaded ZIP file")
# Check if any valid input source is provided
if repo_file is None:
logger.error("No input source provided")
return "❌ Please upload a repository ZIP file, single file, or clone from GitHub.", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
logger.info(f"Processing with file: {repo_file.name}")
try:
file_path = repo_file.name
file_size = os.path.getsize(file_path)
# Initial status
status = f"""✅ Processing started!
📁 File: {Path(file_path).name}
📊 Size: {file_size / 1024:.2f} KB
🎯 Target: {target_version}
"""
progress(0.05, desc="Starting...")
yield status, gr.update(visible=False), gr.update(visible=False), gr.update(visible=False) # Hide download buttons initially
# Create a callback to update progress from orchestrator
current_status = [status] # Use list to allow modification in nested function
def progress_callback(phase, message):
"""Callback to update progress from orchestrator."""
phase_progress = {
"Phase 1": 0.15,
"Phase 2": 0.30,
"Phase 3": 0.45,
"Phase 4": 0.65,
"Phase 5": 0.85
}
prog_value = phase_progress.get(phase, 0.5)
progress(prog_value, desc=f"{phase}: {message}")
current_status[0] += f"⏳ {phase}: {message}\n"
# Run orchestrator with callback
progress(0.1, desc="Initializing workflow...")
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
results = loop.run_until_complete(
orchestrator.modernize_repository(
repo_path=file_path,
target_version=target_version,
create_pr=create_pr,
repo_url=repo_url if create_pr else None,
github_token=github_token if github_token and github_token.strip() else None,
progress_callback=progress_callback
)
)
loop.close()
progress(0.95, desc="Preparing downloads...")
status = current_status[0]
# Prepare download files
modernized_zip = None
tests_zip = None
report_file = None
if results.get('output'):
import zipfile
import tempfile
import time
# Create timestamp for file naming
timestamp = time.strftime("%Y%m%d_%H%M%S")
output_dir = Path(results['output']['modernized_files'])
# Get list of files that were actually transformed in this run
transformed_files = []
if results.get('phases', {}).get('transformation'):
# Extract file paths from transformation results
for t in results.get('transformations', []):
if 'file_path' in t:
transformed_files.append(Path(t['file_path']).name)
# Create ZIP of modernized files with better naming - ONLY current run files
if output_dir.exists() and transformed_files:
modernized_zip = tempfile.NamedTemporaryFile(
delete=False,
suffix='.zip',
prefix=f'modernized_code_{timestamp}_'
)
with zipfile.ZipFile(modernized_zip.name, 'w', zipfile.ZIP_DEFLATED) as zipf:
# Only include files from current transformation
for file in output_dir.iterdir():
if file.is_file() and file.name in transformed_files:
zipf.write(file, file.name)
modernized_zip.close()
else:
modernized_zip = None
# Create ZIP of test files with better naming - ONLY current run files
tests_dir = Path(results['output']['test_files'])
if tests_dir.exists() and transformed_files:
tests_zip = tempfile.NamedTemporaryFile(
delete=False,
suffix='.zip',
prefix=f'test_files_{timestamp}_'
)
with zipfile.ZipFile(tests_zip.name, 'w', zipfile.ZIP_DEFLATED) as zipf:
# Only include test files from current transformation
for file in tests_dir.iterdir():
if file.is_file():
# Check if this test file corresponds to a transformed file
test_base = file.name.replace('test_', '')
if test_base in transformed_files:
zipf.write(file, file.name)
tests_zip.close()
else:
tests_zip = None
# Create report file with UTF-8 encoding and better naming
report_file = tempfile.NamedTemporaryFile(
delete=False,
suffix='.txt',
prefix=f'modernization_report_{timestamp}_',
mode='w',
encoding='utf-8'
)
report_content = orchestrator.generate_report(results)
report_file.write(report_content)
report_file.close()
# Generate final report
if results['success']:
status += "\n" + "=" * 60 + "\n"
status += "✅ MODERNIZATION COMPLETE!\n"
status += "=" * 60 + "\n\n"
stats = results.get('statistics', {})
status += f"📊 **Statistics:**\n"
status += f" • Total files: {stats.get('total_files', 0)}\n"
status += f" • Files modernized: {stats.get('files_modernized', 0)}\n"
status += f" • Tests generated: {stats.get('tests_generated', 0)}\n"
status += f" • Test pass rate: {stats.get('test_pass_rate', 0):.1f}%\n"
# Only show coverage if it's greater than 0
if stats.get('average_coverage', 0) > 0:
status += f" • Code coverage: {stats.get('average_coverage', 0):.1f}%\n"
status += "\n"
# Phase details
phases = results.get('phases', {})
if 'classification' in phases:
c = phases['classification']
status += f"📋 **Classification:**\n"
status += f" • High priority: {c.get('modernize_high', 0)} files\n"
status += f" • Low priority: {c.get('modernize_low', 0)} files\n"
status += f" • Skip: {c.get('skip', 0)} files\n\n"
if 'search' in phases:
s = phases['search']
status += f"🔍 **Semantic Search:**\n"
status += f" • Indexed files: {s.get('indexed_files', 0)}\n"
status += f" • Pattern groups: {s.get('pattern_groups', 0)}\n\n"
if 'validation' in phases:
v = phases['validation']
status += f"✅ **Validation:**\n"
status += f" • Tests run: {v.get('total_tests', 0)}\n"
status += f" • Tests passed: {v.get('tests_passed', 0)}\n"
status += f" • Tests failed: {v.get('tests_failed', 0)}\n"
status += f" • Pass rate: {v.get('pass_rate', 0):.1f}%\n"
# Show execution mode
exec_mode = v.get('execution_mode', 'unknown')
if exec_mode == 'modal':
status += f" • Execution: 🚀 Modal (cloud)\n\n"
elif exec_mode == 'local':
status += f" • Execution: 💻 Local\n\n"
else:
status += f"\n"
if 'github_pr' in phases:
pr = phases['github_pr']
if pr.get('success'):
status += f"🔗 **GitHub PR:**\n"
status += f" • PR URL: {pr.get('pr_url', 'N/A')}\n"
status += f" • PR Number: #{pr.get('pr_number', 0)}\n"
status += f" • Branch: {pr.get('branch', 'N/A')}\n\n"
else:
status += f"⚠️ **GitHub PR:** {pr.get('error', 'Failed')}\n\n"
if results.get('errors'):
status += f"⚠️ **Warnings:**\n"
for error in results['errors'][:5]:
status += f" • {error}\n"
# Add output locations
if results.get('output'):
status += f"\n📁 **Output Locations:**\n"
status += f" • Modernized files: {results['output']['modernized_files']}\n"
status += f" • Test files: {results['output']['test_files']}\n"
status += f" • Original files: {results['output']['original_files']}\n"
status += "\n" + "=" * 60 + "\n"
status += "🎉 Ready for review and deployment!\n"
status += "📥 Download files using the buttons below.\n"
else:
status += "\n❌ MODERNIZATION FAILED\n\n"
status += "Errors:\n"
for error in results.get('errors', []):
status += f" • {error}\n"
progress(1.0, desc="Complete!")
# Final yield with status and download files (make visible)
yield (
status,
gr.update(value=modernized_zip.name, visible=True) if modernized_zip else gr.update(visible=False),
gr.update(value=tests_zip.name, visible=True) if tests_zip else gr.update(visible=False),
gr.update(value=report_file.name, visible=True) if report_file else gr.update(visible=False)
)
except Exception as e:
logger.error(f"Error in modernize_code: {e}", exc_info=True)
progress(1.0, desc="Error occurred")
yield f"❌ Error: {str(e)}\n\nPlease check logs for details.", gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
# Custom CSS for better styling
custom_css = """
.gradio-container {
font-family: 'Inter', sans-serif;
}
.header {
text-align: center;
padding: 20px;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
border-radius: 10px;
margin-bottom: 20px;
}
/* Style token input to match other inputs */
.token-input input {
background-color: var(--input-background-fill) !important;
border: 1px solid var(--input-border-color) !important;
}
"""
# Get execution mode info for display
from src.sandbox.config import EXECUTION_MODE, IS_HUGGINGFACE, MODAL_CONFIGURED
exec_mode_display = ""
if IS_HUGGINGFACE:
if MODAL_CONFIGURED:
exec_mode_display = "🚀 Running on Hugging Face Spaces with Modal (cloud execution)"
else:
exec_mode_display = "⚠️ Running on Hugging Face but Modal not configured - tests will fail!"
elif EXECUTION_MODE == "modal":
exec_mode_display = "🚀 Modal execution enabled (cloud)"
elif EXECUTION_MODE == "local":
exec_mode_display = "💻 Local execution mode"
else:
exec_mode_display = "" # Don't show anything for auto mode
# Build Gradio interface
with gr.Blocks(title="Legacy Code Modernizer") as app:
# Add custom CSS via HTML
gr.HTML(f"""
""")
gr.Markdown("""
### Modernization Workflow:
1. **Discovery & Classification**: Analyze codebase structure and prioritize files
2. **Semantic Search**: Group similar patterns using vector-based search
3. **Code Transformation**: Apply AI-powered modernization patterns
4. **Testing & Validation**: Generate tests and validate in secure sandbox
5. **GitHub Integration**: Create pull requests with comprehensive documentation
**Powered by**: Google Gemini, Nebius AI, LlamaIndex, Chroma, Modal, MCP Protocol
""")
with gr.Row():
with gr.Column(scale=2):
# Input method selection
with gr.Tabs() as input_tabs:
with gr.Tab("📄 Single File"):
single_file_input = gr.File(
label="Upload Single Code File",
file_types=[
".py", ".pyw", ".pyx",
".java",
".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"
],
type="filepath"
)
file_status = gr.Textbox(
label="File Status",
lines=8,
interactive=False,
visible=True
)
single_file_path = gr.State(value=None)
gr.Markdown("""
**Supported Languages**:
- Python (.py, .pyw, .pyx) - pytest with coverage
- Java (.java) - Maven + JUnit 5 + JaCoCo
- JavaScript (.js, .jsx, .mjs, .cjs) - Jest with coverage
- TypeScript (.ts, .tsx) - Jest with coverage
**Max file size**: 10 MB per file
**Note**: All supported languages include code transformation, test generation, and secure Modal sandbox execution with automatic dependency management.
""")
with gr.Tab("📁 Upload ZIP"):
file_input = gr.File(
label="Upload Repository (.zip)",
file_types=[".zip"],
type="filepath"
)
with gr.Tab("🔗 Clone from GitHub"):
github_repo_url = gr.Textbox(
label="GitHub Repository URL",
placeholder="https://github.com/owner/repo",
info="Enter full GitHub URL to clone (without .git extension)"
)
clone_btn = gr.Button(
"📥 Load Repository",
variant="secondary",
size="sm"
)
clone_status = gr.Textbox(
label="Repository Files",
lines=15,
interactive=False,
visible=False
)
cloned_repo_path = gr.State(value=None)
gr.Markdown("**Note**: Requires git to be installed on your system")
# Build comprehensive target version list
all_target_versions = []
for versions in TARGET_VERSIONS.values():
all_target_versions.extend(versions)
all_target_versions.extend(FRAMEWORK_VERSIONS)
all_target_versions = sorted(set(all_target_versions))
target_version = gr.Dropdown(
choices=all_target_versions,
label="🎯 Target Version (auto-detected from files)",
value="Python 3.14",
info="Automatically updated based on uploaded files",
allow_custom_value=False
)
# Add option to select from full list
with gr.Accordion("📋 Browse All Versions", open=False):
gr.Markdown("""
**Auto-detection incorrect?** Select from the full list below:
**Python**: 3.14, 3.13, 3.12, 3.11, 3.10
**Java**: 25 LTS, 23, 21 LTS, 17 LTS
**JavaScript**: ES2025, ES2024, Node.js 25, 24 LTS, 22 LTS
**TypeScript**: 5.9, 5.8, 5.7, 5.6
**Frameworks**: React 19, Angular 21, Vue 3.5, Django 5.2 LTS, Spring Boot 4.0, Laravel 12, Rails 8.1, Next.js 16, FastAPI 0.122, and more
Simply select your desired version from the dropdown above.
""")
with gr.Accordion("⚙️ Advanced Options", open=False):
create_pr = gr.Checkbox(
label="Create GitHub PR",
value=False,
info="Automatically create pull request with modernized code"
)
repo_url = gr.Textbox(
label="GitHub Repository URL for PR",
placeholder="owner/repo (e.g., myorg/myproject)",
info="Required if creating PR"
)
github_token_input = gr.Textbox(
label="GitHub Personal Access Token",
placeholder="ghp_xxxxxxxxxxxxxxxxxxxx",
type="password",
info="Required for PR creation. Leave empty to use token from .env file",
container=True,
elem_classes=["token-input"]
)
process_btn = gr.Button(
"🚀 Start Modernization",
variant="primary",
size="lg"
)
with gr.Column(scale=3):
output = gr.Textbox(
label="📊 Status & Progress",
lines=25,
max_lines=35
)
# Download section (separate row, below main interface)
with gr.Row():
download_modernized = gr.File(
label="📦 Download Modernized Code",
visible=False
)
download_tests = gr.File(
label="🧪 Download Test Files",
visible=False
)
download_report = gr.File(
label="📄 Download Report",
visible=False
)
with gr.Accordion("📖 Features & Capabilities", open=False):
gr.Markdown("""
### Core Features:
**🔍 Semantic Code Search**
- Vector-based similarity search using LlamaIndex and Chroma
- Automatic pattern grouping for efficient refactoring
- Bulk code transformation capabilities
**🤖 AI-Powered Analysis**
- Powered by Google Gemini and Nebius AI models
- Large context window for comprehensive code understanding
- Multi-language support (Python, Java, JavaScript, TypeScript)
**🧪 Automated Testing**
- Isolated test execution in Modal sandbox
- Secure environment with no network access
- Performance benchmarking and coverage reporting
**🔗 GitHub Integration**
- Automated pull request creation via MCP Protocol
- Comprehensive documentation generation
- Deployment checklists and rollback plans
**📊 Quality Assurance**
- High test pass rates with comprehensive coverage
- Behavioral equivalence testing
- Automated validation before deployment
""")
with gr.Accordion("🎯 Supported Languages & Versions", open=False):
gr.Markdown("""
### Supported Languages (Updated November 2025):
**Python**
- Versions: 3.9, 3.10, 3.11, 3.12, 3.13
- Frameworks: Django 5.1, Flask 3.1, FastAPI 0.115
- Testing: pytest with coverage
**Java**
- Versions: Java 11 LTS, 17 LTS, 21 LTS, 23
- Frameworks: Spring Boot 3.4
- Testing: Maven + JUnit 5 + JaCoCo
**JavaScript**
- Standards: ES2023, ES2024, ES2025
- Runtimes: Node.js 20 LTS, 22 LTS, 23
- Frameworks: React 19, Angular 19, Vue 3.5, Express 5.0, Next.js 15
- Testing: Jest with coverage
**TypeScript**
- Versions: 5.4, 5.5, 5.6, 5.7
- Frameworks: React 19, Angular 19, Vue 3.5, Next.js 15
- Testing: Jest with ts-jest
""")
# State for suggested versions
suggested_versions_state = gr.State(value=[])
# Event handlers
# Handle single file validation (automatic on upload)
def validate_and_show(file_path):
"""Wrapper to validate file and show status."""
logger.info(f"validate_and_show called with file_path: {file_path}")
if not file_path:
logger.warning("No file path provided to validate_and_show")
return "📄 Upload a code file to get started", None, gr.update(), []
try:
message, zip_path, suggested_versions = process_single_file(file_path)
logger.info(f"Validation result: message='{message}', zip_path='{zip_path}', versions={len(suggested_versions)}")
# Update dropdown with suggested versions
if suggested_versions:
return message, zip_path, gr.update(choices=suggested_versions, value=suggested_versions[0]), suggested_versions
else:
return message, zip_path, gr.update(), []
except Exception as e:
logger.error(f"Error in validate_and_show: {e}", exc_info=True)
return f"❌ Error: {str(e)}", None, gr.update(), []
# Handle ZIP file upload
def handle_zip_upload(file_path):
"""Handle ZIP file upload and detect languages."""
if not file_path:
return gr.update(), []
try:
lang_summary, suggested_versions = detect_languages_from_zip(file_path)
logger.info(f"ZIP upload: {lang_summary}, {len(suggested_versions)} versions")
if suggested_versions:
return gr.update(choices=suggested_versions, value=suggested_versions[0]), suggested_versions
else:
return gr.update(), []
except Exception as e:
logger.error(f"Error handling ZIP upload: {e}")
return gr.update(), []
# Auto-validate on file upload
single_file_input.change(
fn=validate_and_show,
inputs=[single_file_input],
outputs=[file_status, single_file_path, target_version, suggested_versions_state],
show_progress=True
)
# Auto-detect on ZIP upload
file_input.change(
fn=handle_zip_upload,
inputs=[file_input],
outputs=[target_version, suggested_versions_state],
show_progress=False
)
# Handle GitHub clone button
def handle_github_clone(github_url):
"""Wrapper for GitHub clone with version detection."""
status, zip_path, visibility, suggested_versions = clone_github_repo(github_url)
if suggested_versions:
return status, zip_path, visibility, gr.update(choices=suggested_versions, value=suggested_versions[0]), suggested_versions
else:
return status, zip_path, visibility, gr.update(), []
clone_btn.click(
fn=handle_github_clone,
inputs=[github_repo_url],
outputs=[clone_status, cloned_repo_path, clone_status, target_version, suggested_versions_state],
show_progress=True
)
# Handle modernization
process_btn.click(
fn=modernize_code,
inputs=[file_input, target_version, create_pr, repo_url, github_token_input, cloned_repo_path, single_file_path],
outputs=[output, download_modernized, download_tests, download_report],
show_progress="full"
)
# Examples
gr.Examples(
examples=[
[None, "Python 3.12", False, "", "", None, None],
[None, "Java 21 LTS", False, "", "", None, None],
[None, "React 18 (Hooks)", True, "myorg/myproject", "", None, None]
],
inputs=[file_input, target_version, create_pr, repo_url, github_token_input, cloned_repo_path, single_file_path],
label="📝 Example Configurations"
)
if __name__ == "__main__":
app.launch(
server_name="0.0.0.0",
server_port=7860,
share=False,
show_error=True,
css=custom_css
)