Spaces:

SyedTahir
/

STHASI-Code-Review-Assistant

Sleeping

Update app.py

8bc5435 verified about 1 year ago

13.9 kB

import gradio as gr
import os
from transformers import pipeline
import torch
import re
import ast
import traceback

# Initialize a more suitable model for code analysis
code_analyzer = None

def load_analyzer():
    global code_analyzer
    if code_analyzer is None:
        try:
            # Using a text generation model that's better for code analysis
            code_analyzer = pipeline(
                "text-generation",
                model="Salesforce/codegen-350M-mono",
                device=0 if torch.cuda.is_available() else -1
            )
        except:
            code_analyzer = "fallback"
    return code_analyzer

def check_python_syntax(code):
    """Check Python syntax errors"""
    errors = []
    try:
        ast.parse(code)
    except SyntaxError as e:
        errors.append({
            'type': 'Syntax Error',
            'line': e.lineno,
            'message': e.msg,
            'text': e.text.strip() if e.text else ''
        })
    except Exception as e:
        errors.append({
            'type': 'Parse Error',
            'line': None,
            'message': str(e),
            'text': ''
        })
    return errors

def check_common_errors(code, language):
    """Detect common coding errors"""
    errors = []
    lines = code.split('\n')
    
    if language.lower() == 'python':
        # Check for missing colons
        for i, line in enumerate(lines, 1):
            stripped = line.strip()
            if stripped and not stripped.startswith('#'):
                if any(stripped.startswith(kw) for kw in ['def ', 'class ', 'if ', 'elif ', 'else', 'for ', 'while ', 'try', 'except', 'finally', 'with ']):
                    if not stripped.endswith(':') and not stripped.endswith('\\'):
                        errors.append({
                            'type': 'Missing Colon',
                            'line': i,
                            'message': 'Missing colon at end of statement',
                            'text': stripped
                        })
        
        # Check for missing parentheses
        for i, line in enumerate(lines, 1):
            if 'def ' in line or 'for ' in line or 'while ' in line:
                if '(' not in line or ')' not in line:
                    errors.append({
                        'type': 'Missing Parentheses',
                        'line': i,
                        'message': 'Missing parentheses in statement',
                        'text': line.strip()
                    })
        
        # Check for undefined variables (simple check)
        defined_vars = set()
        for i, line in enumerate(lines, 1):
            # Track variable assignments
            if '=' in line and not line.strip().startswith('#'):
                parts = line.split('=')[0].strip()
                if ' ' not in parts or parts.split()[0] in ['for']:
                    var_name = parts.split()[-1].strip('()')
                    defined_vars.add(var_name)
            
            # Check for undefined variable usage
            words = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', line)
            for word in words:
                if word not in ['def', 'class', 'if', 'else', 'elif', 'for', 'while', 'in', 'return', 'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple']:
                    # Check if it looks like it's being used but not defined
                    if word not in defined_vars and f'{word}(' not in line and f'{word} =' not in line:
                        if re.search(rf'\b{word}\b(?!\s*=)(?!\s*\()', line):
                            errors.append({
                                'type': 'Potential Undefined Variable',
                                'line': i,
                                'message': f"Variable '{word}' may not be defined",
                                'text': line.strip()
                            })
    
    return errors

def analyze_code_structure(code, language):
    """Analyze code structure and provide metrics"""
    lines = code.split('\n')
    total_lines = len(lines)
    code_lines = len([l for l in lines if l.strip() and not l.strip().startswith('#') and not l.strip().startswith('//')])
    comment_lines = len([l for l in lines if l.strip().startswith('#') or l.strip().startswith('//')])
    blank_lines = total_lines - code_lines - comment_lines
    
    # Calculate complexity
    complexity_keywords = ['if', 'else', 'elif', 'for', 'while', 'switch', 'case', 'catch', 'try']
    complexity = sum(code.lower().count(keyword) for keyword in complexity_keywords)
    
    # Check for functions
    func_count = len(re.findall(r'\bdef\s+\w+\s*\(', code)) if language.lower() == 'python' else len(re.findall(r'\bfunction\s+\w+\s*\(', code))
    
    return {
        'total_lines': total_lines,
        'code_lines': code_lines,
        'comment_lines': comment_lines,
        'blank_lines': blank_lines,
        'complexity': complexity,
        'functions': func_count
    }

def detect_vulnerabilities(code, language):
    """Detect common security vulnerabilities"""
    vulnerabilities = []
    
    patterns = {
        'SQL Injection': [r'execute\s*\(.*\+.*\)', r'query\s*\(.*\+.*\)', r'SELECT.*\+.*FROM'],
        'Hardcoded Secrets': [r'password\s*=\s*["\'][^"\']+["\']', r'api_key\s*=\s*["\'][^"\']+["\']', r'secret\s*=\s*["\'][^"\']+["\']'],
        'Command Injection': [r'os\.system\s*\(', r'subprocess\.call\s*\(', r'eval\s*\(', r'exec\s*\('],
        'Path Traversal': [r'\.\./', r'open\s*\(.*\+.*\)'],
        'XSS Vulnerability': [r'innerHTML\s*=', r'document\.write\s*\('],
    }
    
    for vuln_type, pattern_list in patterns.items():
        for pattern in pattern_list:
            if re.search(pattern, code, re.IGNORECASE):
                vulnerabilities.append(vuln_type)
                break
    
    return list(set(vulnerabilities))

def generate_smart_suggestions(code, language, errors):
    """Generate intelligent code suggestions based on detected issues"""
    suggestions = []
    
    # Suggestions based on errors
    if errors:
        suggestions.append("**Critical Issues Found:**")
        for error in errors[:5]:  # Limit to first 5 errors
            suggestions.append(f"- Line {error['line']}: {error['type']} - {error['message']}")
            if error['text']:
                suggestions.append(f"  ```{language.lower()}\n  {error['text']}\n  ```")
    
    # Code quality suggestions
    metrics = analyze_code_structure(code, language)
    
    if metrics['comment_lines'] == 0 and metrics['code_lines'] > 5:
        suggestions.append("\n**Documentation:**")
        suggestions.append("- Add comments to explain complex logic")
        suggestions.append("- Consider adding docstrings to functions")
    
    if metrics['complexity'] > 10:
        suggestions.append("\n**Complexity:**")
        suggestions.append("- High cyclomatic complexity detected. Consider breaking down complex functions")
    
    # Language-specific suggestions
    if language.lower() == 'python':
        if 'print(' in code and '+' in code:
            suggestions.append("\n**String Formatting:**")
            suggestions.append("- Use f-strings instead of string concatenation: `f'The average is {average}'`")
        
        if not re.search(r'if\s+__name__\s*==\s*["\']__main__["\']', code) and metrics['code_lines'] > 10:
            suggestions.append("\n**Best Practices:**")
            suggestions.append("- Add `if __name__ == '__main__':` guard for script execution")
    
    return "\n".join(suggestions) if suggestions else "Code looks good! Consider adding more comments for better maintainability."

def review_code(code, language):
    """Main code review function"""
    if not code.strip():
        return "⚠️ Please enter some code to review.", "", ""
    
    # Check for syntax and common errors
    all_errors = []
    if language.lower() == 'python':
        syntax_errors = check_python_syntax(code)
        all_errors.extend(syntax_errors)
    
    common_errors = check_common_errors(code, language)
    all_errors.extend(common_errors)
    
    # Analyze code structure
    metrics = analyze_code_structure(code, language)
    
    # Detect vulnerabilities
    vulnerabilities = detect_vulnerabilities(code, language)
    
    # Generate smart suggestions
    suggestions = generate_smart_suggestions(code, language, all_errors)
    
    # Format metrics output
    quality_score = 100
    if metrics['comment_lines'] == 0:
        quality_score -= 20
    if all_errors:
        quality_score -= len(all_errors) * 10
    if metrics['complexity'] > 10:
        quality_score -= 15
    quality_score = max(0, quality_score)
    
    metrics_output = f"""## 📊 Code Metrics
- **Total Lines:** {metrics['total_lines']}
- **Code Lines:** {metrics['code_lines']}
- **Comment Lines:** {metrics['comment_lines']}
- **Blank Lines:** {metrics['blank_lines']}
- **Functions:** {metrics['functions']}
- **Cyclomatic Complexity:** {metrics['complexity']}
- **Comment Ratio:** {(metrics['comment_lines'] / max(metrics['code_lines'], 1) * 100):.1f}%
- **Quality Score:** {quality_score}/100 {'🟢' if quality_score >= 70 else '🟡' if quality_score >= 40 else '🔴'}
"""
    
    # Format errors and vulnerabilities
    issues_output = ""
    
    if all_errors:
        issues_output += "## ❌ Errors Detected\n\n"
        for i, error in enumerate(all_errors[:10], 1):  # Show first 10 errors
            issues_output += f"{i}. **{error['type']}** (Line {error['line']})\n"
            issues_output += f"   - {error['message']}\n"
            if error['text']:
                issues_output += f"   - Code: `{error['text']}`\n"
            issues_output += "\n"
    
    if vulnerabilities:
        issues_output += "## 🔒 Security Vulnerabilities\n\n"
        for vuln in vulnerabilities:
            issues_output += f"- ⚠️ **{vuln}**\n"
        issues_output += "\n**Recommendation:** Review and fix these security issues before deployment.\n"
    
    if not all_errors and not vulnerabilities:
        issues_output = "## ✅ No Critical Issues Detected\n\nNo syntax errors or obvious security issues found."
    
    # Format suggestions
    suggestions_output = f"""## 💡 Suggestions for Improvement
{suggestions}
### General Best Practices:
- Write unit tests for your functions
- Use meaningful variable and function names
- Keep functions small and focused (Single Responsibility Principle)
- Handle exceptions appropriately
- Follow {language} PEP 8 style guide (for Python) or equivalent standards
"""
    
    return metrics_output, issues_output, suggestions_output

# Custom CSS
custom_css = """
#header {
    text-align: center;
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    padding: 30px;
    border-radius: 10px;
    margin-bottom: 20px;
    color: white;
}
#header h1 {
    margin: 0;
    font-size: 2.5em;
    font-weight: bold;
}
#header p {
    margin: 10px 0 0 0;
    font-size: 1.1em;
    opacity: 0.9;
}
.footer {
    text-align: center;
    margin-top: 30px;
    padding: 20px;
    background: #f8f9fa;
    border-radius: 10px;
}
.footer a {
    color: #667eea;
    text-decoration: none;
    font-weight: bold;
    margin: 0 10px;
}
.footer a:hover {
    text-decoration: underline;
}
"""

# Create Gradio interface
with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
    gr.HTML("""
        <div id="header">
            <h1>🔍 STHASI Code Review Assistant</h1>
            <p>AI-Powered Code Analysis, Quality Metrics & Security Vulnerability Detection</p>
        </div>
    """)
    
    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("### 📝 Input Code")
            language = gr.Dropdown(
                choices=["Python", "JavaScript", "Java", "C++", "C#", "Go", "Ruby", "PHP", "TypeScript", "Swift"],
                value="Python",
                label="Programming Language"
            )
            code_input = gr.Code(
                label="Paste your code here",
                language="python",
                lines=15
            )
            review_btn = gr.Button("🚀 Review Code", variant="primary", size="lg")
            
            gr.Markdown("""
            ### 📌 Features:
            - **Syntax error detection**
            - **Code quality metrics**
            - **Security vulnerability scan**
            - **Smart improvement suggestions**
            - **Multi-language support**
            """)
    
    with gr.Row():
        with gr.Column():
            metrics_output = gr.Markdown(label="Code Metrics")
        
    with gr.Row():
        with gr.Column():
            issues_output = gr.Markdown(label="Issues & Security")
    
    with gr.Row():
        with gr.Column():
            suggestions_output = gr.Markdown(label="Suggestions")
    
    gr.HTML("""
        <div class="footer">
            <a href="https://www.linkedin.com/in/syedtahirhussan/" target="_blank">🔗 LinkedIn</a>
            <a href="https://github.com/SyedTahirHussan" target="_blank">💻 GitHub</a>
            <p style="font-size: 0.9em; margin-top: 10px; color: black;">Built with ❤️ by <a href="https://www.linkedin.com/in/syedtahirhussan/" target="_blank" style="color: black; text-decoration: underline;">Syed Tahir Hussan</a></p>
            <p style="margin-top: 15px; color: #666;">Powered by Advanced Static Analysis | Gradio 5.49.1</p>
        </div>
    """)
    
    review_btn.click(
        fn=review_code,
        inputs=[code_input, language],
        outputs=[metrics_output, issues_output, suggestions_output]
    )
    
    language.change(
        fn=lambda x: gr.Code(language=x.lower()),
        inputs=[language],
        outputs=[code_input]
    )

if __name__ == "__main__":
    demo.launch()

	import gradio as gr
	import os
	from transformers import pipeline
	import torch
	import re
	import ast
	import traceback

	# Initialize a more suitable model for code analysis
	code_analyzer = None

	def load_analyzer():
	global code_analyzer
	if code_analyzer is None:
	try:
	# Using a text generation model that's better for code analysis
	code_analyzer = pipeline(
	"text-generation",
	model="Salesforce/codegen-350M-mono",
	device=0 if torch.cuda.is_available() else -1
	)
	except:
	code_analyzer = "fallback"
	return code_analyzer

	def check_python_syntax(code):
	"""Check Python syntax errors"""
	errors = []
	try:
	ast.parse(code)
	except SyntaxError as e:
	errors.append({
	'type': 'Syntax Error',
	'line': e.lineno,
	'message': e.msg,
	'text': e.text.strip() if e.text else ''
	})
	except Exception as e:
	errors.append({
	'type': 'Parse Error',
	'line': None,
	'message': str(e),
	'text': ''
	})
	return errors

	def check_common_errors(code, language):
	"""Detect common coding errors"""
	errors = []
	lines = code.split('\n')

	if language.lower() == 'python':
	# Check for missing colons
	for i, line in enumerate(lines, 1):
	stripped = line.strip()
	if stripped and not stripped.startswith('#'):
	if any(stripped.startswith(kw) for kw in ['def ', 'class ', 'if ', 'elif ', 'else', 'for ', 'while ', 'try', 'except', 'finally', 'with ']):
	if not stripped.endswith(':') and not stripped.endswith('\\'):
	errors.append({
	'type': 'Missing Colon',
	'line': i,
	'message': 'Missing colon at end of statement',
	'text': stripped
	})

	# Check for missing parentheses
	for i, line in enumerate(lines, 1):
	if 'def ' in line or 'for ' in line or 'while ' in line:
	if '(' not in line or ')' not in line:
	errors.append({
	'type': 'Missing Parentheses',
	'line': i,
	'message': 'Missing parentheses in statement',
	'text': line.strip()
	})

	# Check for undefined variables (simple check)
	defined_vars = set()
	for i, line in enumerate(lines, 1):
	# Track variable assignments
	if '=' in line and not line.strip().startswith('#'):
	parts = line.split('=')[0].strip()
	if ' ' not in parts or parts.split()[0] in ['for']:
	var_name = parts.split()[-1].strip('()')
	defined_vars.add(var_name)

	# Check for undefined variable usage
	words = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', line)
	for word in words:
	if word not in ['def', 'class', 'if', 'else', 'elif', 'for', 'while', 'in', 'return', 'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple']:
	# Check if it looks like it's being used but not defined
	if word not in defined_vars and f'{word}(' not in line and f'{word} =' not in line:
	if re.search(rf'\b{word}\b(?!\s=)(?!\s\()', line):
	errors.append({
	'type': 'Potential Undefined Variable',
	'line': i,
	'message': f"Variable '{word}' may not be defined",
	'text': line.strip()
	})

	return errors

	def analyze_code_structure(code, language):
	"""Analyze code structure and provide metrics"""
	lines = code.split('\n')
	total_lines = len(lines)
	code_lines = len([l for l in lines if l.strip() and not l.strip().startswith('#') and not l.strip().startswith('//')])
	comment_lines = len([l for l in lines if l.strip().startswith('#') or l.strip().startswith('//')])
	blank_lines = total_lines - code_lines - comment_lines

	# Calculate complexity
	complexity_keywords = ['if', 'else', 'elif', 'for', 'while', 'switch', 'case', 'catch', 'try']
	complexity = sum(code.lower().count(keyword) for keyword in complexity_keywords)

	# Check for functions
	func_count = len(re.findall(r'\bdef\s+\w+\s\(', code)) if language.lower() == 'python' else len(re.findall(r'\bfunction\s+\w+\s\(', code))

	return {
	'total_lines': total_lines,
	'code_lines': code_lines,
	'comment_lines': comment_lines,
	'blank_lines': blank_lines,
	'complexity': complexity,
	'functions': func_count
	}

	def detect_vulnerabilities(code, language):
	"""Detect common security vulnerabilities"""
	vulnerabilities = []

	patterns = {
	'SQL Injection': [r'execute\s\(.\+.\)', r'query\s\(.\+.\)', r'SELECT.\+.FROM'],
	'Hardcoded Secrets': [r'password\s=\s["\'][^"\']+["\']', r'api_key\s=\s["\'][^"\']+["\']', r'secret\s=\s["\'][^"\']+["\']'],
	'Command Injection': [r'os\.system\s\(', r'subprocess\.call\s\(', r'eval\s\(', r'exec\s\('],
	'Path Traversal': [r'\.\./', r'open\s\(.\+.*\)'],
	'XSS Vulnerability': [r'innerHTML\s=', r'document\.write\s\('],
	}

	for vuln_type, pattern_list in patterns.items():
	for pattern in pattern_list:
	if re.search(pattern, code, re.IGNORECASE):
	vulnerabilities.append(vuln_type)
	break

	return list(set(vulnerabilities))

	def generate_smart_suggestions(code, language, errors):
	"""Generate intelligent code suggestions based on detected issues"""
	suggestions = []

	# Suggestions based on errors
	if errors:
	suggestions.append("Critical Issues Found:")
	for error in errors[:5]: # Limit to first 5 errors
	suggestions.append(f"- Line {error['line']}: {error['type']} - {error['message']}")
	if error['text']:
	suggestions.append(f" ```{language.lower()}\n {error['text']}\n ```")

	# Code quality suggestions
	metrics = analyze_code_structure(code, language)

	if metrics['comment_lines'] == 0 and metrics['code_lines'] > 5:
	suggestions.append("\nDocumentation:")
	suggestions.append("- Add comments to explain complex logic")
	suggestions.append("- Consider adding docstrings to functions")

	if metrics['complexity'] > 10:
	suggestions.append("\nComplexity:")
	suggestions.append("- High cyclomatic complexity detected. Consider breaking down complex functions")

	# Language-specific suggestions
	if language.lower() == 'python':
	if 'print(' in code and '+' in code:
	suggestions.append("\nString Formatting:")
	suggestions.append("- Use f-strings instead of string concatenation: `f'The average is {average}'`")

	if not re.search(r'if\s+__name__\s==\s["\']__main__["\']', code) and metrics['code_lines'] > 10:
	suggestions.append("\nBest Practices:")
	suggestions.append("- Add `if __name__ == '__main__':` guard for script execution")

	return "\n".join(suggestions) if suggestions else "Code looks good! Consider adding more comments for better maintainability."

	def review_code(code, language):
	"""Main code review function"""
	if not code.strip():
	return "⚠️ Please enter some code to review.", "", ""

	# Check for syntax and common errors
	all_errors = []
	if language.lower() == 'python':
	syntax_errors = check_python_syntax(code)
	all_errors.extend(syntax_errors)

	common_errors = check_common_errors(code, language)
	all_errors.extend(common_errors)

	# Analyze code structure
	metrics = analyze_code_structure(code, language)

	# Detect vulnerabilities
	vulnerabilities = detect_vulnerabilities(code, language)

	# Generate smart suggestions
	suggestions = generate_smart_suggestions(code, language, all_errors)

	# Format metrics output
	quality_score = 100
	if metrics['comment_lines'] == 0:
	quality_score -= 20
	if all_errors:
	quality_score -= len(all_errors) * 10
	if metrics['complexity'] > 10:
	quality_score -= 15
	quality_score = max(0, quality_score)

	metrics_output = f"""## 📊 Code Metrics

	- Total Lines: {metrics['total_lines']}
	- Code Lines: {metrics['code_lines']}
	- Comment Lines: {metrics['comment_lines']}
	- Blank Lines: {metrics['blank_lines']}
	- Functions: {metrics['functions']}
	- Cyclomatic Complexity: {metrics['complexity']}
	- Comment Ratio: {(metrics['comment_lines'] / max(metrics['code_lines'], 1) * 100):.1f}%
	- Quality Score: {quality_score}/100 {'🟢' if quality_score >= 70 else '🟡' if quality_score >= 40 else '🔴'}
	"""

	# Format errors and vulnerabilities
	issues_output = ""

	if all_errors:
	issues_output += "## ❌ Errors Detected\n\n"
	for i, error in enumerate(all_errors[:10], 1): # Show first 10 errors
	issues_output += f"{i}. {error['type']} (Line {error['line']})\n"
	issues_output += f" - {error['message']}\n"
	if error['text']:
	issues_output += f" - Code: `{error['text']}`\n"
	issues_output += "\n"

	if vulnerabilities:
	issues_output += "## 🔒 Security Vulnerabilities\n\n"
	for vuln in vulnerabilities:
	issues_output += f"- ⚠️ {vuln}\n"
	issues_output += "\nRecommendation: Review and fix these security issues before deployment.\n"

	if not all_errors and not vulnerabilities:
	issues_output = "## ✅ No Critical Issues Detected\n\nNo syntax errors or obvious security issues found."

	# Format suggestions
	suggestions_output = f"""## 💡 Suggestions for Improvement

	{suggestions}

	### General Best Practices:
	- Write unit tests for your functions
	- Use meaningful variable and function names
	- Keep functions small and focused (Single Responsibility Principle)
	- Handle exceptions appropriately
	- Follow {language} PEP 8 style guide (for Python) or equivalent standards
	"""

	return metrics_output, issues_output, suggestions_output

	# Custom CSS
	custom_css = """
	#header {
	text-align: center;
	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
	padding: 30px;
	border-radius: 10px;
	margin-bottom: 20px;
	color: white;
	}

	#header h1 {
	margin: 0;
	font-size: 2.5em;
	font-weight: bold;
	}

	#header p {
	margin: 10px 0 0 0;
	font-size: 1.1em;
	opacity: 0.9;
	}

	.footer {
	text-align: center;
	margin-top: 30px;
	padding: 20px;
	background: #f8f9fa;
	border-radius: 10px;
	}

	.footer a {
	color: #667eea;
	text-decoration: none;
	font-weight: bold;
	margin: 0 10px;
	}

	.footer a:hover {
	text-decoration: underline;
	}
	"""

	# Create Gradio interface
	with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
	gr.HTML("""
	<div id="header">
	<h1>🔍 STHASI Code Review Assistant</h1>
	<p>AI-Powered Code Analysis, Quality Metrics & Security Vulnerability Detection</p>
	</div>
	""")

	with gr.Row():
	with gr.Column(scale=1):
	gr.Markdown("### 📝 Input Code")
	language = gr.Dropdown(
	choices=["Python", "JavaScript", "Java", "C++", "C#", "Go", "Ruby", "PHP", "TypeScript", "Swift"],
	value="Python",
	label="Programming Language"
	)
	code_input = gr.Code(
	label="Paste your code here",
	language="python",
	lines=15
	)
	review_btn = gr.Button("🚀 Review Code", variant="primary", size="lg")

	gr.Markdown("""
	### 📌 Features:
	- Syntax error detection
	- Code quality metrics
	- Security vulnerability scan
	- Smart improvement suggestions
	- Multi-language support
	""")

	with gr.Row():
	with gr.Column():
	metrics_output = gr.Markdown(label="Code Metrics")

	with gr.Row():
	with gr.Column():
	issues_output = gr.Markdown(label="Issues & Security")

	with gr.Row():
	with gr.Column():
	suggestions_output = gr.Markdown(label="Suggestions")

	gr.HTML("""
	<div class="footer">
	<a href="https://www.linkedin.com/in/syedtahirhussan/" target="_blank">🔗 LinkedIn</a>
	<a href="https://github.com/SyedTahirHussan" target="_blank">💻 GitHub</a>
	<p style="font-size: 0.9em; margin-top: 10px; color: black;">Built with ❤️ by <a href="https://www.linkedin.com/in/syedtahirhussan/" target="_blank" style="color: black; text-decoration: underline;">Syed Tahir Hussan</a></p>
	<p style="margin-top: 15px; color: #666;">Powered by Advanced Static Analysis \| Gradio 5.49.1</p>
	</div>
	""")

	review_btn.click(
	fn=review_code,
	inputs=[code_input, language],
	outputs=[metrics_output, issues_output, suggestions_output]
	)

	language.change(
	fn=lambda x: gr.Code(language=x.lower()),
	inputs=[language],
	outputs=[code_input]
	)

	if __name__ == "__main__":
	demo.launch()