Create main.py

main.py

@@ -0,0 +1,347 @@
+import streamlit as st
+import requests
+import time
+import json
+import google.generativeai as genai
+from langchain_core.prompts import PromptTemplate
+from langchain_google_genai import GoogleGenerativeAI
+from dotenv import load_dotenv
+
+# Configure page
+st.set_page_config(
+    page_title="GitHub Repository Analyzer",
+    page_icon="🔍",
+    layout="wide"
+)
+
+# Add custom CSS
+st.markdown("""
+    <style>
+    .metric-card {
+        background-color: #f0f2f6;
+        padding: 20px;
+        border-radius: 10px;
+        margin: 10px 0;
+    }
+    .repo-card {
+        background-color: white;
+        padding: 20px;
+        border-radius: 10px;
+        margin: 10px 0;
+        border: 1px solid #e6e6e6;
+    }
+    .stTextArea textarea {
+        height: 200px;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'analysis_complete' not in st.session_state:
+    st.session_state.analysis_complete = False
+if 'github_token' not in st.session_state:
+    st.session_state.github_token = ""
+if 'gemini_key' not in st.session_state:
+    st.session_state.gemini_key = ""
+
+def initialize_api(github_token, gemini_key):
+    """Initialize API configurations"""
+    try:
+        headers = {"Authorization": f"token {github_token}", "Accept": "application/vnd.github.v3+json"}
+        
+        # Configure Gemini API
+        genai.configure(api_key=gemini_key)
+        llm = GoogleGenerativeAI(model="gemini-1.5-flash", temperature=0.2, google_api_key=gemini_key)
+        
+        # Test the configuration
+        test_response = llm.invoke("Test")
+        return headers, llm
+    except Exception as e:
+        st.error(f"Error initializing APIs: {str(e)}")
+        st.error("Please ensure your API keys are correct and try again.")
+        return None, None
+
+def get_github_repos(username, headers):
+    """Fetch repositories from a user's GitHub profile."""
+    url = f"https://api.github.com/users/{username}/repos"
+    response = requests.get(url, headers=headers)
+
+    if response.status_code == 200:
+        return response.json()
+    else:
+        st.error(f"Failed to fetch repositories. Status code: {response.status_code}")
+        return []
+
+def get_repo_details(username, repo_name, headers):
+    """Fetch README, latest commits, and repo structure."""
+    readme_url = f"https://api.github.com/repos/{username}/{repo_name}/readme"
+    commits_url = f"https://api.github.com/repos/{username}/{repo_name}/commits"
+    contents_url = f"https://api.github.com/repos/{username}/{repo_name}/contents"
+    languages_url = f"https://api.github.com/repos/{username}/{repo_name}/languages"
+
+    readme_content = ""
+    commit_messages = []
+    file_structure = []
+    languages_used = []
+
+    with st.spinner(f"Fetching details for {repo_name}..."):
+        # Fetch README
+        readme_response = requests.get(readme_url, headers=headers)
+        if readme_response.status_code == 200:
+            readme_content = requests.get(readme_response.json()['download_url']).text
+
+        # Fetch latest 5 commits
+        commit_response = requests.get(commits_url, headers=headers)
+        if commit_response.status_code == 200:
+            commit_messages = [commit['commit']['message'] for commit in commit_response.json()[:5]]
+
+        # Fetch file structure
+        content_response = requests.get(contents_url, headers=headers)
+        if content_response.status_code == 200:
+            file_structure = [file['name'] for file in content_response.json()]
+
+        # Fetch languages used
+        lang_response = requests.get(languages_url, headers=headers)
+        if lang_response.status_code == 200:
+            languages_used = list(lang_response.json().keys())
+
+    return readme_content, commit_messages, file_structure, languages_used
+
+def analyze_repo_and_jd_match(readme, file_structure, commits, languages, jd, llm):
+    """Use Gemini AI to analyze repository and match with JD."""
+    prompt_template = PromptTemplate(
+        input_variables=["readme", "files", "commits", "languages", "jd"],
+        template="""
+        You are an AI technical recruiter. Analyze the following GitHub project details and job description:
+        
+        Job Description:
+        {jd}
+        
+        Repository Details:
+        README: {readme}
+        File Structure: {files}
+        Commit Messages: {commits}
+        Languages: {languages}
+        
+        Provide output as structured JSON:
+        {{
+            "languages": ["list of languages"],
+            "tech_stack": ["list of frameworks & libraries"],
+            "algorithms": ["list of key algorithms used"],
+            "complexity": "low/medium/high",
+            "commit_activity": "active/moderate/inactive",
+            "jd_match_score": "1-100",
+            "jd_match_reasons": ["list of reasons why this repository matches or doesn't match the JD"]
+        }}
+        """
+    )
+
+    try:
+        response = llm.invoke(prompt_template.format(
+            readme=readme, 
+            files=", ".join(file_structure),
+            commits=", ".join(commits), 
+            languages=", ".join(languages),
+            jd=jd
+        ))
+        
+        json_start = response.find("{")
+        json_end = response.rfind("}") + 1
+        json_data = json.loads(response[json_start:json_end].strip())
+        
+        return json_data
+
+    except Exception as e:
+        st.error(f"Error analyzing repository: {e}")
+        return {
+            "languages": [],
+            "tech_stack": [],
+            "algorithms": [],
+            "complexity": "unknown",
+            "commit_activity": "unknown",
+            "jd_match_score": 0,
+            "jd_match_reasons": []
+        }
+
+def calculate_repo_score(analysis_data):
+    """Calculate a score for a repository based on its analysis and JD match."""
+    base_score = 0
+    
+    # Score based on number of languages (max 10 points)
+    base_score += min(len(analysis_data['languages']) * 2, 10)
+    
+    # Score based on tech stack (max 15 points)
+    base_score += min(len(analysis_data['tech_stack']) * 3, 15)
+    
+    # Score based on algorithms (max 15 points)
+    base_score += min(len(analysis_data['algorithms']) * 3, 15)
+    
+    # Score based on complexity (max 30 points)
+    complexity_scores = {"low": 10, "medium": 20, "high": 30, "unknown": 0}
+    base_score += complexity_scores.get(analysis_data['complexity'].lower(), 0)
+    
+    # Score based on commit activity (max 30 points)
+    activity_scores = {"inactive": 10, "moderate": 20, "active": 30, "unknown": 0}
+    base_score += activity_scores.get(analysis_data['commit_activity'].lower(), 0)
+    
+    # Include JD match score in final calculation
+    jd_match_score = float(analysis_data.get('jd_match_score', 0))
+    
+    # Final score is weighted average of base score and JD match score
+    final_score = (base_score * 0.6) + (jd_match_score * 0.4)
+    
+    return round(final_score)
+
+def evaluate_candidate(total_score, num_repos):
+    """Evaluate candidate suitability based on average repository score."""
+    if num_repos == 0:
+        return "Unable to evaluate - no repositories found"
+    
+    avg_score = total_score / num_repos
+    if avg_score >= 75:
+        return "Highly Suitable"
+    elif avg_score >= 50:
+        return "Moderately Suitable"
+    elif avg_score >= 25:
+        return "Potentially Suitable"
+    else:
+        return "Not Suitable"
+
+def display_repo_analysis(repo_name, analysis_data, repo_score):
+    """Display repository analysis in Streamlit."""
+    with st.expander(f"📁 {repo_name} - Score: {repo_score}/100", expanded=True):
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("### 🛠 Technical Details")
+            st.write("**Languages:**", ", ".join(analysis_data['languages']))
+            st.write("**Tech Stack:**", ", ".join(analysis_data['tech_stack']) if analysis_data['tech_stack'] else "None detected")
+            st.write("**Algorithms:**", ", ".join(analysis_data['algorithms']) if analysis_data['algorithms'] else "None detected")
+        
+        with col2:
+            st.markdown("### 📊 Metrics")
+            st.write("**Complexity:**", analysis_data['complexity'].capitalize())
+            st.write("**Commit Activity:**", analysis_data['commit_activity'].capitalize())
+            st.write("**JD Match Score:**", f"{analysis_data.get('jd_match_score', 0)}/100")
+            st.progress(repo_score/100)
+        
+        if analysis_data.get('jd_match_reasons'):
+            st.markdown("### 🎯 JD Match Analysis")
+            for reason in analysis_data['jd_match_reasons']:
+                st.write(f"- {reason}")
+
+def analyze_github_repos(username, headers, llm, jd):
+    """Analyze GitHub projects and generate summaries."""
+    repos = get_github_repos(username, headers)
+    if not repos:
+        st.error("No repositories found or failed to fetch repositories.")
+        return []
+
+    results = []
+    total_score = 0
+    progress_bar = st.progress(0)
+
+    for idx, repo in enumerate(repos):
+        repo_name = repo['name']
+        with st.spinner(f"Analyzing {repo_name}..."):
+            readme, commits, file_structure, languages = get_repo_details(username, repo_name, headers)
+            analysis_data = analyze_repo_and_jd_match(readme, file_structure, commits, languages, jd, llm)
+            repo_score = calculate_repo_score(analysis_data)
+            total_score += repo_score
+            results.append((repo_name, analysis_data, repo_score))
+            
+        progress_bar.progress((idx + 1) / len(repos))
+        time.sleep(1)
+
+    progress_bar.empty()
+    return results, total_score
+
+def main():
+    st.title("🔍 GitHub Repository Analyzer")
+    st.markdown("""
+    This tool analyzes GitHub repositories to evaluate technical capabilities and project quality.
+    Please provide the required information below to begin the analysis.
+    """)
+
+    # API Keys input
+    with st.expander("🔑 API Configuration", expanded=True):
+        col1, col2 = st.columns(2)
+        with col1:
+            github_token = st.text_input("GitHub Token", type="password", 
+                                       value=st.session_state.get('github_token', ''))
+        with col2:
+            gemini_key = st.text_input("Google Gemini API Key", type="password",
+                                     value=st.session_state.get('gemini_key', ''))
+
+    # Job Description input
+    st.subheader("📝 Job Description")
+    jd = st.text_area("Paste the job description here", height=200)
+
+    # GitHub username input
+    username = st.text_input("👤 Enter GitHub Username")
+
+    # Save API keys to session state
+    if github_token:
+        st.session_state.github_token = github_token
+    if gemini_key:
+        st.session_state.gemini_key = gemini_key
+
+    if st.button("Analyze Repositories") and username and jd and github_token and gemini_key:
+        headers, llm = initialize_api(github_token, gemini_key)
+        
+        if headers and llm:
+            with st.spinner("Analyzing repositories..."):
+                repo_analysis, total_score = analyze_github_repos(username, headers, llm, jd)
+                
+                if repo_analysis:
+                    num_repos = len(repo_analysis)
+                    
+                    # Display overall summary
+                    st.header("📊 Analysis Summary")
+                    col1, col2, col3 = st.columns(3)
+                    
+                    with col1:
+                        st.metric("Total Repositories", num_repos)
+                    with col2:
+                        avg_score = round(total_score / num_repos if num_repos > 0 else 0)
+                        st.metric("Average Repository Score", f"{avg_score}/100")
+                    with col3:
+                        suitability = evaluate_candidate(total_score, num_repos)
+                        st.metric("Candidate Suitability", suitability)
+                    
+                    # Display individual repository analysis
+                    st.header("📁 Repository Details")
+                    sorted_analysis = sorted(repo_analysis, key=lambda x: x[2], reverse=True)
+                    
+                    for repo_name, analysis_data, repo_score in sorted_analysis:
+                        display_repo_analysis(repo_name, analysis_data, repo_score)
+                    
+                    # Export option
+                    if st.button("Export Analysis"):
+                        export_data = {
+                            "username": username,
+                            "total_repos": num_repos,
+                            "average_score": avg_score,
+                            "suitability": suitability,
+                            "repositories": [
+                                {
+                                    "name": repo_name,
+                                    "score": repo_score,
+                                    "analysis": analysis_data
+                                }
+                                for repo_name, analysis_data, repo_score in sorted_analysis
+                            ]
+                        }
+                        st.download_button(
+                            "Download Analysis Report",
+                            data=json.dumps(export_data, indent=2),
+                            file_name=f"github_analysis_{username}.json",
+                            mime="application/json"
+                        )
+                else:
+                    st.error("No repositories found or analysis failed.")
+        else:
+            st.error("Failed to initialize APIs. Please check your API keys and try again.")
+
+if __name__ == "__main__":
+    main()