Update app.py

app.py

@@ -1,24 +1,104 @@
 import gradio as gr
 import os
-from transformers import AutoTokenizer, AutoModelForCausalLM
+from transformers import pipeline
 import torch
 import re
+import ast
+import traceback
 
-# Initialize model and tokenizer
-MODEL_NAME = "bigcode/starcoderbase-1b"
-tokenizer = None
-model = None
+# Initialize a more suitable model for code analysis
+code_analyzer = None
 
-def load_model():
-    global tokenizer, model
-    if tokenizer is None:
-        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        model = AutoModelForCausalLM.from_pretrained(
-            MODEL_NAME,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            device_map="auto"
-        )
-    return tokenizer, model
+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"""
@@ -28,23 +108,26 @@ def analyze_code_structure(code, language):
     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 (simple heuristic)
+    # 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
+        'complexity': complexity,
+        'functions': func_count
     }
 
 def detect_vulnerabilities(code, language):
     """Detect common security vulnerabilities"""
     vulnerabilities = []
     
-    # Common vulnerability patterns
     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*["\'][^"\']+["\']'],
@@ -61,89 +144,122 @@ def detect_vulnerabilities(code, language):
     
     return list(set(vulnerabilities))
 
-def generate_ai_suggestions(code, language):
-    """Generate AI-powered code suggestions"""
-    try:
-        tokenizer, model = load_model()
-        
-        prompt = f"""# Code Review for {language}
-# Analyze the following code and provide suggestions for improvement:
-
-{code[:500]}  # Limit input for faster processing
-
-# Suggestions:
-1."""
-        
-        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
-        
-        with torch.no_grad():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=200,
-                temperature=0.7,
-                do_sample=True,
-                top_p=0.95,
-                pad_token_id=tokenizer.eos_token_id
-            )
-        
-        suggestion = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        # Extract only the generated part
-        suggestion = suggestion.split("# Suggestions:")[-1].strip()
-        
-        return suggestion if suggestion else "Consider adding more comments and following best practices for code readability."
+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}'`")
         
-    except Exception as e:
-        return f"AI suggestion generation in progress... Meanwhile, consider: proper error handling, code documentation, and following {language} best practices."
+        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 AI suggestions
-    ai_suggestions = generate_ai_suggestions(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 vulnerabilities output
+    # 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:
-        vuln_output = "## 🔒 Security Vulnerabilities Detected\n\n"
+        issues_output += "## 🔒 Security Vulnerabilities\n\n"
         for vuln in vulnerabilities:
-            vuln_output += f"- ⚠️ **{vuln}**\n"
-        vuln_output += "\n**Recommendation:** Review and fix these security issues before deployment."
-    else:
-        vuln_output = "## ✅ No Common Vulnerabilities Detected\n\nNo obvious security issues found. However, always perform thorough security testing."
+            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 AI suggestions
-    suggestions_output = f"""## 🤖 AI-Powered Suggestions
+    # Format suggestions
+    suggestions_output = f"""## 💡 Suggestions for Improvement
 
-{ai_suggestions}
+{suggestions}
 
 ### General Best Practices:
-- Ensure proper error handling
-- Add comprehensive documentation
-- Follow {language} coding standards
-- Write unit tests for critical functions
-- Use meaningful variable names
-- Keep functions small and focused
+- 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, vuln_output, suggestions_output
+    return metrics_output, issues_output, suggestions_output
 
 # Custom CSS
 custom_css = """
@@ -190,7 +306,6 @@ custom_css = """
 
 # Create Gradio interface
 with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
-    # Header
     gr.HTML("""
         <div id="header">
             <h1>🔍 STHASI Code Review Assistant</h1>
@@ -216,10 +331,11 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
             
             gr.Markdown("""
             ### 📌 Features:
-            - Code quality metrics
-            - Security vulnerability detection
-            - AI-powered suggestions
-            - Multi-language support
+            - **Syntax error detection**
+            - **Code quality metrics**
+            - **Security vulnerability scan**
+            - **Smart improvement suggestions**
+            - **Multi-language support**
             """)
     
     with gr.Row():
@@ -228,36 +344,32 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
         
     with gr.Row():
         with gr.Column():
-            vuln_output = gr.Markdown(label="Security Analysis")
+            issues_output = gr.Markdown(label="Issues & Security")
     
     with gr.Row():
         with gr.Column():
-            suggestions_output = gr.Markdown(label="AI Suggestions")
+            suggestions_output = gr.Markdown(label="Suggestions")
     
-    # Footer
     gr.HTML("""
         <div class="footer">
             <p><strong>Connect with me:</strong></p>
             <a href="https://www.linkedin.com/in/syedtahirhussan/" target="_blank">🔗 LinkedIn</a>
             <a href="https://github.com/SyedTahirHussan" target="_blank">💻 GitHub</a>
-            <p style="margin-top: 15px; color: #666;">Powered by StarCoder AI Model | Gradio 5.49.1</p>
+            <p style="margin-top: 15px; color: #666;">Powered by Advanced Static Analysis | Gradio 5.49.1</p>
         </div>
     """)
     
-    # Event handler
     review_btn.click(
         fn=review_code,
         inputs=[code_input, language],
-        outputs=[metrics_output, vuln_output, suggestions_output]
+        outputs=[metrics_output, issues_output, suggestions_output]
     )
     
-    # Update code editor language when dropdown changes
     language.change(
         fn=lambda x: gr.Code(language=x.lower()),
         inputs=[language],
         outputs=[code_input]
     )
 
-# Launch the app
 if __name__ == "__main__":
     demo.launch()