diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -1,519 +1,3530 @@
-import gradio as gr
-import google.generativeai as genai
-import os
-from dotenv import load_dotenv
-from github import Github
+# Import existing libraries from the original code
+import requests
 import json
-from pathlib import Path
-from datetime import datetime
-from collections import defaultdict
+import os
 import base64
-from typing import Dict, List, Any, Optional, Tuple
-import tempfile
-from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+import re
+import ast
+import networkx as nx
+import radon.metrics as metrics
+import radon.complexity as complexity
+from datetime import datetime, timedelta
+from collections import defaultdict, Counter
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+from IPython.display import display, Markdown, HTML
+import numpy as np
+from github import Github, GithubException
 import time
-import os
+from dotenv import load_dotenv
 
+# Import Neo4j and Gemini libraries
+from neo4j import GraphDatabase, basic_auth
+import google.generativeai as genai
 
+# Import Vizro and Gradio
+import vizro.plotly.express as px
+import vizro
+import vizro.models as vzm
+import plotly.graph_objects as go
+import gradio as gr
 
-# Load environment variables
-load_dotenv()
+# Keep GitHubRepoInfo class unchanged
+class GitHubRepoInfo:
+    """Enhanced class to get comprehensive information about a GitHub repository."""
+
+    def __init__(self, token=None):
+        """Initialize with optional GitHub API token."""
+        self.base_url = "https://api.github.com"
+        self.headers = {"Accept": "application/vnd.github.v3+json"}
+        self.token = token
+        self.github = None # Initialize github attribute
+
+        # Set up authentication
+        if token:
+            self.headers["Authorization"] = f"token {token}"
+            try:
+                self.github = Github(token)
+                self.github.get_user().login # Test connection
+            except Exception as e:
+                print(f"Warning: Failed to initialize PyGithub with token: {e}")
+                self.github = Github() # Fallback to unauthenticated
+        elif os.environ.get("GITHUB_TOKEN"):
+            self.token = os.environ.get("GITHUB_TOKEN")
+            self.headers["Authorization"] = f"token {self.token}"
+            try:
+                self.github = Github(self.token)
+                self.github.get_user().login # Test connection
+            except Exception as e:
+                print(f"Warning: Failed to initialize PyGithub with token: {e}")
+                self.github = Github() # Fallback to unauthenticated
+        else:
+            self.github = Github() # Unauthenticated
+
+        # Configure rate limit handling
+        self.rate_limit_remaining = 5000 # Assume higher limit if authenticated
+        self.rate_limit_reset = datetime.now()
+        # Initialize rate limit info if possible
+        if self.github:
+            try:
+                 rate_limit = self.github.get_rate_limit()
+                 self.rate_limit_remaining = rate_limit.core.remaining
+                 self.rate_limit_reset = datetime.fromtimestamp(rate_limit.core.reset)
+            except Exception as e:
+                 print(f"Warning: Could not get initial rate limit from PyGithub: {e}")
+
+
+    # --- Keep ALL existing methods from the original GitHubRepoInfo class ---
+    # ... ( _check_rate_limit, _paginated_get, get_repo_info, get_contributors, ...)
+    def _check_rate_limit(self):
+        """Check API rate limit and wait if necessary."""
+        if self.rate_limit_remaining <= 10:
+            reset_time = self.rate_limit_reset
+            current_time = datetime.now()
+
+            if reset_time > current_time:
+                wait_time = (reset_time - current_time).total_seconds() + 10  # Add buffer
+                print(f"Rate limit nearly exhausted. Waiting {wait_time:.0f} seconds for reset.")
+                time.sleep(wait_time)
+
+        # Update rate limit info after each API call
+        response = requests.get(f"{self.base_url}/rate_limit", headers=self.headers)
+        if response.status_code == 200:
+            rate_data = response.json()
+            self.rate_limit_remaining = rate_data["resources"]["core"]["remaining"]
+            self.rate_limit_reset = datetime.fromtimestamp(rate_data["resources"]["core"]["reset"])
+
+    def _paginated_get(self, url, params=None, max_items=None):
+        """Handle paginated API responses with rate limit awareness."""
+        if params is None:
+            params = {}
+
+        items = []
+        page = 1
+        per_page = min(100, params.get("per_page", 30))
+        params["per_page"] = per_page
+
+        while True:
+            self._check_rate_limit()
+
+            params["page"] = page
+            response = requests.get(url, headers=self.headers, params=params)
+
+            if response.status_code == 200:
+                page_items = response.json()
+                if not page_items:
+                    break
+
+                items.extend(page_items)
+                page += 1
+
+                # Check if we've reached the requested limit
+                if max_items and len(items) >= max_items:
+                    return items[:max_items]
+
+                # Check if we've reached the end (GitHub returns fewer items than requested)
+                if len(page_items) < per_page:
+                    break
+            else:
+                print(f"Error {response.status_code}: {response.text}")
+                break
+
+        return items
+
+    def get_repo_info(self, owner, repo):
+        """Get basic repository information."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}"
+        response = requests.get(url, headers=self.headers)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"Error {response.status_code}: {response.text}")
+            return None
+
+    def get_contributors(self, owner, repo, max_contributors=None):
+        """Get repository contributors with pagination support."""
+        url = f"{self.base_url}/repos/{owner}/{repo}/contributors"
+        return self._paginated_get(url, max_items=max_contributors)
+
+    # ... ( get_languages, get_commits, get_commit_activity, get_code_frequency, ...)
+    def get_languages(self, owner, repo):
+        """Get languages used in the repository."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}/languages"
+        response = requests.get(url, headers=self.headers)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"Error getting languages: {response.status_code}")
+            return {}
+
+    def get_commits(self, owner, repo, params=None, max_commits=None):
+        """Get commits with enhanced filtering and pagination."""
+        url = f"{self.base_url}/repos/{owner}/{repo}/commits"
+        return self._paginated_get(url, params=params, max_items=max_commits)
+
+    def get_commit_activity(self, owner, repo):
+        """Get commit activity stats for the past year."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}/stats/commit_activity"
+        response = requests.get(url, headers=self.headers)
+
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 202:
+            # GitHub is computing the statistics, wait and retry
+            print("GitHub is computing statistics, waiting and retrying...")
+            time.sleep(2)
+            return self.get_commit_activity(owner, repo)
+        else:
+            print(f"Error getting commit activity: {response.status_code}")
+            return []
+
+    def get_code_frequency(self, owner, repo):
+        """Get weekly code addition and deletion statistics."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}/stats/code_frequency"
+        response = requests.get(url, headers=self.headers)
+
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 202:
+            # GitHub is computing the statistics, wait and retry
+            print("GitHub is computing statistics, waiting and retrying...")
+            time.sleep(2)
+            return self.get_code_frequency(owner, repo)
+        else:
+            print(f"Error getting code frequency: {response.status_code}")
+            return []
+
+
+    # ... ( get_contributor_activity, get_branches, get_releases, get_issues, ...)
+    def get_contributor_activity(self, owner, repo):
+        """Get contributor commit activity over time."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}/stats/contributors"
+        response = requests.get(url, headers=self.headers)
+
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 202:
+            # GitHub is computing the statistics, wait and retry
+            print("GitHub is computing statistics, waiting and retrying...")
+            time.sleep(2)
+            return self.get_contributor_activity(owner, repo)
+        else:
+            print(f"Error getting contributor activity: {response.status_code}")
+            return []
+
+    def get_branches(self, owner, repo):
+        """Get repository branches."""
+        url = f"{self.base_url}/repos/{owner}/{repo}/branches"
+        return self._paginated_get(url)
+
+    def get_releases(self, owner, repo, max_releases=None):
+        """Get repository releases with pagination support."""
+        url = f"{self.base_url}/repos/{owner}/{repo}/releases"
+        return self._paginated_get(url, max_items=max_releases)
+
+    def get_issues(self, owner, repo, state="all", max_issues=None, params=None):
+        """Get repository issues with enhanced filtering."""
+        url = f"{self.base_url}/repos/{owner}/{repo}/issues"
+        if params is None:
+            params = {}
+        params["state"] = state
+        return self._paginated_get(url, params=params, max_items=max_issues)
+
+    # ... ( get_issue_timeline, get_pull_requests, get_pr_timeline, get_contents, ...)
+    def get_issue_timeline(self, owner, repo, days_back=180):
+        """Analyze issue creation and closing over time."""
+        # Get issues including closed ones
+        issues = self.get_issues(owner, repo, state="all")
+
+        # Prepare timeline data
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_back)
+
+        # Initialize daily counters
+        date_range = pd.date_range(start=start_date, end=end_date)
+        created_counts = {d.strftime('%Y-%m-%d'): 0 for d in date_range}
+        closed_counts = {d.strftime('%Y-%m-%d'): 0 for d in date_range}
+
+        # Collect issue creation and closing dates
+        for issue in issues:
+            created_at = datetime.strptime(issue['created_at'], '%Y-%m-%dT%H:%M:%SZ')
+            if created_at >= start_date:
+                created_counts[created_at.strftime('%Y-%m-%d')] += 1
+
+            if issue['state'] == 'closed' and issue.get('closed_at'):
+                closed_at = datetime.strptime(issue['closed_at'], '%Y-%m-%dT%H:%M:%SZ')
+                if closed_at >= start_date:
+                    closed_counts[closed_at.strftime('%Y-%m-%d')] += 1
+
+        # Calculate resolution times for closed issues
+        resolution_times = []
+        for issue in issues:
+            if issue['state'] == 'closed' and issue.get('closed_at'):
+                created_at = datetime.strptime(issue['created_at'], '%Y-%m-%dT%H:%M:%SZ')
+                closed_at = datetime.strptime(issue['closed_at'], '%Y-%m-%dT%H:%M:%SZ')
+                resolution_time = (closed_at - created_at).total_seconds() / 3600  # hours
+                resolution_times.append(resolution_time)
+
+        # Calculate issue labels distribution
+        label_counts = defaultdict(int)
+        for issue in issues:
+            for label in issue.get('labels', []):
+                label_counts[label['name']] += 1
 
-# Configure API keys
-GITHUB_TOKEN = os.getenv("github_api")
-GEMINI_API_KEY = os.getenv("gemini_api") 
+        return {
+            'created': created_counts,
+            'closed': closed_counts,
+            'resolution_times': resolution_times,
+            'labels': dict(label_counts)
+        }
 
-if not GITHUB_TOKEN or not GEMINI_API_KEY:
-    raise ValueError("Both GITHUB_TOKEN and GEMINI_API_KEY must be set in environment")
+    def get_pull_requests(self, owner, repo, state="all", max_prs=None, params=None):
+        """Get repository pull requests with enhanced filtering."""
+        url = f"{self.base_url}/repos/{owner}/{repo}/pulls"
+        if params is None:
+            params = {}
+        params["state"] = state
+        return self._paginated_get(url, params=params, max_items=max_prs)
+
+    def get_pr_timeline(self, owner, repo, days_back=180):
+        """Analyze PR creation, closing, and metrics over time."""
+        # Get PRs including closed and merged ones
+        prs = self.get_pull_requests(owner, repo, state="all")
+
+        # Prepare timeline data
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_back)
+
+        # Initialize daily counters
+        date_range = pd.date_range(start=start_date, end=end_date)
+        created_counts = {d.strftime('%Y-%m-%d'): 0 for d in date_range}
+        closed_counts = {d.strftime('%Y-%m-%d'): 0 for d in date_range}
+        merged_counts = {d.strftime('%Y-%m-%d'): 0 for d in date_range}
+
+        # Track metrics
+        merge_times = []
+        pr_sizes = []
+
+        # Collect PR data
+        for pr in prs:
+            created_at = datetime.strptime(pr['created_at'], '%Y-%m-%dT%H:%M:%SZ')
+            if created_at >= start_date:
+                created_counts[created_at.strftime('%Y-%m-%d')] += 1
+
+                # Get PR size (additions + deletions)
+                if pr.get('additions') is not None and pr.get('deletions') is not None:
+                    pr_sizes.append({
+                        'additions': pr['additions'],
+                        'deletions': pr['deletions'],
+                        'total': pr['additions'] + pr['deletions'],
+                        'files_changed': pr.get('changed_files', 0)
+                    })
+
+            # Check if PR is closed
+            if pr['state'] == 'closed':
+                closed_at = datetime.strptime(pr['closed_at'], '%Y-%m-%dT%H:%M:%SZ')
+                if closed_at >= start_date:
+                    closed_counts[closed_at.strftime('%Y-%m-%d')] += 1
+
+                    # Check if PR was merged
+                    if pr['merged_at']:
+                        merged_at = datetime.strptime(pr['merged_at'], '%Y-%m-%dT%H:%M:%SZ')
+                        if merged_at >= start_date:
+                            merged_counts[merged_at.strftime('%Y-%m-%d')] += 1
+
+                            # Calculate time to merge
+                            merge_time = (merged_at - created_at).total_seconds() / 3600  # hours
+                            merge_times.append(merge_time)
+
+        # Calculate acceptance rate
+        total_closed = sum(closed_counts.values())
+        total_merged = sum(merged_counts.values())
+        acceptance_rate = (total_merged / total_closed) * 100 if total_closed > 0 else 0
+
+        return {
+            'created': created_counts,
+            'closed': closed_counts,
+            'merged': merged_counts,
+            'merge_times': merge_times,
+            'pr_sizes': pr_sizes,
+            'acceptance_rate': acceptance_rate
+        }
+
+    def get_contents(self, owner, repo, path="", ref=None):
+        """Get repository contents at the specified path."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}/contents/{path}"
+        params = {}
+        if ref:
+            params["ref"] = ref
+
+        response = requests.get(url, headers=self.headers, params=params)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"Error getting contents: {response.status_code}")
+            return []
+    # ... ( get_readme, get_file_content, is_text_file, get_recursive_contents, ...)
+    def get_readme(self, owner, repo, ref=None):
+        """Get repository README file."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}/readme"
+        params = {}
+        if ref:
+            params["ref"] = ref
+
+        response = requests.get(url, headers=self.headers, params=params)
+
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("content"):
+                content = base64.b64decode(data["content"]).decode("utf-8")
+                return {
+                    "name": data["name"],
+                    "path": data["path"],
+                    "content": content
+                }
+            return data
+        else:
+            print(f"README not found or error: {response.status_code}")
+            return None
+
+    def get_file_content(self, owner, repo, path, ref=None):
+        """Get the content of a specific file in the repository."""
+        self._check_rate_limit()
+        url = f"{self.base_url}/repos/{owner}/{repo}/contents/{path}"
+        params = {}
+        if ref:
+            params["ref"] = ref
+
+        response = requests.get(url, headers=self.headers, params=params)
+
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("content"):
+                try:
+                    content = base64.b64decode(data["content"]).decode("utf-8")
+                    return content
+                except UnicodeDecodeError:
+                    return "[Binary file content not displayed]"
+            return None
+        else:
+            print(f"Error getting file content: {response.status_code}")
+            return None
+
+    def is_text_file(self, file_path):
+        """Determine if a file is likely a text file based on extension."""
+        text_extensions = [
+            '.txt', '.md', '.rst', '.py', '.js', '.html', '.css', '.java', '.c',
+            '.cpp', '.h', '.hpp', '.json', '.xml', '.yaml', '.yml', '.toml',
+            '.ini', '.cfg', '.conf', '.sh', '.bat', '.ps1', '.rb', '.pl', '.php',
+            '.go', '.rs', '.ts', '.jsx', '.tsx', '.vue', '.swift', '.kt', '.scala',
+            '.groovy', '.lua', '.r', '.dart', '.ex', '.exs', '.erl', '.hrl',
+            '.clj', '.hs', '.elm', '.f90', '.f95', '.f03', '.sql', '.gitignore',
+            '.dockerignore', '.env', '.editorconfig', '.htaccess', '.cs', '.ipynb',
+            '.R', '.Rmd', '.jl', '.fs', '.ml', '.mli', '.d', '.scm', '.lisp',
+            '.el', '.m', '.mm', '.vb', '.asm', '.s', '.Dockerfile', '.gradle'
+        ]
+
+        extension = os.path.splitext(file_path)[1].lower()
+        return extension in text_extensions
+
+    def get_recursive_contents(self, owner, repo, path="", max_depth=3, current_depth=0, max_files=1000, ref=None):
+        """Recursively get repository contents with a depth limit and file count limit."""
+        if current_depth >= max_depth:
+            return []
+
+        contents = self.get_contents(owner, repo, path, ref)
+        results = []
+        file_count = 0
+
+        for item in contents:
+            if file_count >= max_files:
+                break
+
+            if item["type"] == "dir":
+                # For directories, add the directory itself and recursively get contents
+                dir_item = {
+                    "type": "dir",
+                    "name": item["name"],
+                    "path": item["path"],
+                    "contents": self.get_recursive_contents(
+                        owner, repo, item["path"], max_depth, current_depth + 1,
+                        max_files - file_count, ref
+                    )
+                }
+                results.append(dir_item)
+            else:
+                # For files, add the file info
+                results.append({
+                    "type": "file",
+                    "name": item["name"],
+                    "path": item["path"],
+                    "size": item["size"],
+                    "url": item["html_url"]
+                })
+                file_count += 1
+
+        return results
+    # ... ( get_all_text_files, get_documentation_files, analyze_ast, analyze_js_ts, ...)
+    def get_all_text_files(self, owner, repo, path="", max_files=50, ref=None):
+        """Get content of all text files in the repository (with limit)."""
+        contents = self.get_contents(owner, repo, path, ref)
+        text_files = []
+        file_count = 0
+
+        # Process current directory
+        for item in contents:
+            if file_count >= max_files:
+                break
+
+            if item["type"] == "file" and self.is_text_file(item["name"]):
+                content = self.get_file_content(owner, repo, item["path"], ref)
+                if content and content != "[Binary file content not displayed]":
+                    text_files.append({
+                        "name": item["name"],
+                        "path": item["path"],
+                        "content": content
+                    })
+                    file_count += 1
+            elif item["type"] == "dir":
+                # Recursively get text files from subdirectories
+                subdir_files = self.get_all_text_files(
+                    owner, repo, item["path"], max_files - file_count, ref
+                )
+                text_files.extend(subdir_files)
+                file_count += len(subdir_files)
+
+        return text_files
+
+    def get_documentation_files(self, owner, repo, ref=None):
+        """Get documentation files from the repository."""
+        # Common documentation file paths and directories
+        doc_paths = [
+            "docs", "doc", "documentation", "wiki", "CONTRIBUTING.md",
+            "CONTRIBUTORS.md", "CODE_OF_CONDUCT.md", "SECURITY.md",
+            "SUPPORT.md", "docs/index.md", "docs/README.md", "docs/getting-started.md",
+            ".github/ISSUE_TEMPLATE", ".github/PULL_REQUEST_TEMPLATE.md"
+        ]
+
+        doc_files = []
+
+        # Try to get each documentation file/directory
+        for path in doc_paths:
+            try:
+                contents = self.get_contents(owner, repo, path, ref)
+
+                # If it's a directory, get all markdown files in it
+                if isinstance(contents, list):
+                    for item in contents:
+                        if item["type"] == "file" and item["name"].lower().endswith((".md", ".rst", ".txt")):
+                            content = self.get_file_content(owner, repo, item["path"], ref)
+                            if content:
+                                doc_files.append({
+                                    "name": item["name"],
+                                    "path": item["path"],
+                                    "content": content
+                                })
+                # If it's a file, get its content
+                elif isinstance(contents, dict) and contents.get("type") == "file":
+                    content = self.get_file_content(owner, repo, path, ref)
+                    if content:
+                        doc_files.append({
+                            "name": contents["name"],
+                            "path": contents["path"],
+                            "content": content
+                        })
+            except:
+                # Path doesn't exist or access issues
+                continue
+
+        return doc_files
+
+    def analyze_ast(self, code, file_path):
+        """Analyze Python code using AST (Abstract Syntax Tree)."""
+        if not file_path.endswith('.py'):
+            return None
 
-# Initialize APIs
-gh = Github(GITHUB_TOKEN)
-genai.configure(api_key=GEMINI_API_KEY)
-model = genai.GenerativeModel(
-    model_name="gemini-1.5-pro-latest",
-    generation_config = {
-  "temperature": 1,
-  "top_p": 0.95,
-  "top_k": 40,
-  "max_output_tokens": 8192,
-  "response_mime_type": "text/plain",
-},
-    
-    safety_settings=[
-        {
-            "category": "HARM_CATEGORY_HARASSMENT",
-            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-        },
-        {
-            "category": "HARM_CATEGORY_HATE_SPEECH",
-            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-        },
-        {
-            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-        },
-        {
-            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
-        },
-    ]
-)
-
-RELEVANT_EXTENSIONS = {
-    ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".cpp", ".c", ".h",
-    ".hpp", ".rb", ".php", ".go", ".rs", ".swift", ".kt"
-}
-
-class RepositoryAnalyzer:
-    """Handles GitHub repository analysis"""
-
-    def __init__(self, repo_url: str):
-        # Extract owner and repo name from URL
-        parts = repo_url.rstrip('/').split('/')
-        if len(parts) < 2:
-            raise ValueError("Invalid repository URL format")
-
-        self.repo_name = parts[-1]
-        self.owner = parts[-2]
-        self.repo = gh.get_repo(f"{self.owner}/{self.repo_name}")
-        self.analysis_data: Dict[str, Any] = {}
-
-    def analyze(self) -> Dict[str, Any]:
-        """Perform complete repository analysis"""
         try:
-            # Basic repository information
-            self.analysis_data["basic_info"] = {
-                "name": self.repo.name,
-                "owner": self.repo.owner.login,
-                "description": self.repo.description or "No description available",
-                "stars": self.repo.stargazers_count,
-                "forks": self.repo.forks_count,
-                "created_at": self.repo.created_at.isoformat(),
-                "last_updated": self.repo.updated_at.isoformat(),
-                "primary_language": self.repo.language or "Not specified",
+            tree = ast.parse(code)
+
+            # Extract more detailed information using AST
+            functions = []
+            classes = []
+            imports = []
+            function_complexities = {}
+
+            for node in ast.walk(tree):
+                # Get function definitions with arguments
+                if isinstance(node, ast.FunctionDef):
+                    args = []
+                    defaults = len(node.args.defaults)
+                    args_count = len(node.args.args) - defaults
+
+                    # Get positional args
+                    for arg in node.args.args[:args_count]:
+                        if hasattr(arg, 'arg'):  # Python 3
+                            args.append(arg.arg)
+                        else:  # Python 2
+                            args.append(arg.id)
+
+                    # Get args with defaults
+                    for i, arg in enumerate(node.args.args[args_count:]):
+                        if hasattr(arg, 'arg'):  # Python 3
+                            args.append(f"{arg.arg}=...")
+                        else:  # Python 2
+                            args.append(f"{arg.id}=...")
+
+                    # Calculate function complexity
+                    func_complexity = complexity.cc_visit(node)
+                    function_complexities[node.name] = func_complexity
+
+                    # Get docstring if available
+                    docstring = ast.get_docstring(node)
+
+                    functions.append({
+                        'name': node.name,
+                        'args': args,
+                        'complexity': func_complexity,
+                        'docstring': docstring
+                    })
+
+                # Get class definitions
+                elif isinstance(node, ast.ClassDef):
+                    methods = []
+                    class_docstring = ast.get_docstring(node)
+
+                    # Get class methods
+                    for child in node.body:
+                        if isinstance(child, ast.FunctionDef):
+                            method_complexity = complexity.cc_visit(child)
+                            method_docstring = ast.get_docstring(child)
+
+                            methods.append({
+                                'name': child.name,
+                                'complexity': method_complexity,
+                                'docstring': method_docstring
+                            })
+
+                    classes.append({
+                        'name': node.name,
+                        'methods': methods,
+                        'docstring': class_docstring
+                    })
+
+                # Get imports
+                elif isinstance(node, ast.Import):
+                    for name in node.names:
+                        imports.append(name.name)
+                elif isinstance(node, ast.ImportFrom):
+                    module = node.module or ""
+                    for name in node.names:
+                        imports.append(f"{module}.{name.name}")
+
+            # Calculate overall code complexity
+            code_complexity = complexity.cc_visit_ast(tree)
+
+            # Calculate maintainability index
+            try:
+                mi_score = metrics.mi_visit(code, True)
+            except:
+                mi_score = None
+
+            return {
+                'functions': functions,
+                'classes': classes,
+                'imports': imports,
+                'complexity': {
+                    'overall': code_complexity,
+                    'functions': function_complexities,
+                    'maintainability_index': mi_score
+                }
             }
 
-            # Analyze repository structure
-            self.analysis_data["structure"] = self._analyze_structure()
+        except SyntaxError:
+            print(f"Syntax error in Python file: {file_path}")
+            return None
+        except Exception as e:
+            print(f"Error analyzing {file_path}: {str(e)}")
+            return None
+
+    def analyze_js_ts(self, code, file_path):
+        """Analyze JavaScript/TypeScript code using regex with improved patterns."""
+        if not file_path.endswith(('.js', '.ts', '.jsx', '.tsx')):
+            return None
+
+        # More sophisticated regex patterns for JS/TS analysis
+        results = {
+            'functions': [],
+            'classes': [],
+            'imports': [],
+            'exports': [],
+            'hooks': []  # For React hooks
+        }
+
+        # Function patterns (covering various declaration styles)
+        function_patterns = [
+            # Regular functions
+            r'function\s+(\w+)\s*\(([^)]*)\)',
+            # Arrow functions assigned to variables
+            r'(?:const|let|var)\s+(\w+)\s*=\s*(?:\([^)]*\)|[^=]*)\s*=>\s*{',
+            # Class methods
+            r'(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*{',
+            # Object methods
+            r'(\w+)\s*:\s*function\s*\(([^)]*)\)'
+        ]
+
+        for pattern in function_patterns:
+            for match in re.finditer(pattern, code):
+                func_name = match.group(1)
+                args = match.group(2).strip() if len(match.groups()) > 1 else ""
+                results['functions'].append({
+                    'name': func_name,
+                    'args': args
+                })
+
+        # Class pattern
+        class_pattern = r'class\s+(\w+)(?:\s+extends\s+(\w+))?\s*{([^}]*)}'
+        for match in re.finditer(class_pattern, code, re.DOTALL):
+            class_name = match.group(1)
+            parent_class = match.group(2) if match.group(2) else None
+            class_body = match.group(3)
+
+            # Find methods in class
+            methods = []
+            method_pattern = r'(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*{([^}]*)}'
+            for method_match in re.finditer(method_pattern, class_body):
+                method_name = method_match.group(1)
+                methods.append(method_name)
+
+            results['classes'].append({
+                'name': class_name,
+                'extends': parent_class,
+                'methods': methods
+            })
+
+        # Import patterns
+        import_patterns = [
+            # ES6 imports
+            r'import\s+(?:{([^}]*)}|\*\s+as\s+(\w+)|(\w+))\s+from\s+[\'"]([^\'"]+)[\'"]',
+            # CommonJS requires
+            r'(?:const|let|var)\s+(?:{([^}]*)}|(\w+))\s*=\s*require\([\'"]([^\'"]+)[\'"]\)'
+        ]
+
+        for pattern in import_patterns:
+            for match in re.finditer(pattern, code):
+                groups = match.groups()
+                if groups[0]:  # Destructured import
+                    imports = [name.strip() for name in groups[0].split(',')]
+                    for imp in imports:
+                        results['imports'].append(imp)
+                elif groups[1]:  # Namespace import (import * as X)
+                    results['imports'].append(groups[1])
+                elif groups[2]:  # Default import
+                    results['imports'].append(groups[2])
+                elif groups[3]:  # Module name
+                    results['imports'].append(groups[3])
+
+        # React hooks detection (for React files)
+        if file_path.endswith(('.jsx', '.tsx')):
+            hook_pattern = r'use([A-Z]\w+)\s*\('
+            for match in re.finditer(hook_pattern, code):
+                hook_name = 'use' + match.group(1)
+                results['hooks'].append(hook_name)
+
+        # Export patterns
+        export_patterns = [
+            # Named exports
+            r'export\s+(?:const|let|var|function|class)\s+(\w+)',
+            # Default exports
+            r'export\s+default\s+(?:function|class)?\s*(\w+)?'
+        ]
+
+        for pattern in export_patterns:
+            for match in re.finditer(pattern, code):
+                if match.group(1):
+                    results['exports'].append(match.group(1))
+
+        return results
+    # ... ( extract_code_summary, analyze_dependencies, create_dependency_graph, ...)
+    def extract_code_summary(self, file_content, file_path):
+        """Extract comprehensive summary information from code files."""
+        extension = os.path.splitext(file_path)[1].lower()
+
+        # Initialize summary
+        summary = {
+            "functions": [],
+            "classes": [],
+            "imports": [],
+            "description": "",
+            "complexity": None
+        }
 
-            # Analyze code patterns
-            self.analysis_data["code_patterns"] = self._analyze_code_patterns()
+        # Extract Python definitions with AST
+        if extension == '.py':
+            ast_result = self.analyze_ast(file_content, file_path)
+            if ast_result:
+                summary["functions"] = [f["name"] for f in ast_result["functions"]]
+                summary["classes"] = [c["name"] for c in ast_result["classes"]]
+                summary["imports"] = ast_result["imports"]
+                summary["complexity"] = ast_result["complexity"]
 
-            # Analyze commit history
-            self.analysis_data["commit_history"] = self._analyze_commits()
+                # Try to extract module docstring
+                try:
+                    tree = ast.parse(file_content)
+                    module_docstring = ast.get_docstring(tree)
+                    if module_docstring:
+                        summary["description"] = module_docstring
+                except:
+                    pass
+
+                # Add detailed function and class info
+                summary["detailed_functions"] = ast_result["functions"]
+                summary["detailed_classes"] = ast_result["classes"]
+
+        # Extract JavaScript/TypeScript definitions
+        elif extension in ['.js', '.ts', '.jsx', '.tsx']:
+            js_result = self.analyze_js_ts(file_content, file_path)
+            if js_result:
+                summary["functions"] = [f["name"] for f in js_result["functions"]]
+                summary["classes"] = [c["name"] for c in js_result["classes"]]
+                summary["imports"] = js_result["imports"]
+
+                # Add detailed function and class info
+                summary["detailed_functions"] = js_result["functions"]
+                summary["detailed_classes"] = js_result["classes"]
+                summary["hooks"] = js_result.get("hooks", [])
+                summary["exports"] = js_result.get("exports", [])
+
+        # Calculate basic code metrics for any text file
+        if file_content:
+            lines = file_content.split('\n')
+            code_lines = 0
+            comment_lines = 0
+            blank_lines = 0
+
+            comment_prefixes = ['#', '//', '/*', '*', '<!--']
+
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    blank_lines += 1
+                elif any(line.startswith(prefix) for prefix in comment_prefixes):
+                    comment_lines += 1
+                else:
+                    code_lines += 1
+
+            summary["metrics"] = {
+                "total_lines": len(lines),
+                "code_lines": code_lines,
+                "comment_lines": comment_lines,
+                "blank_lines": blank_lines,
+                "comment_ratio": comment_lines / max(1, code_lines + comment_lines)
+            }
 
-            # Get contributor statistics
-            self.analysis_data["contributors"] = self._analyze_contributors()
+        return summary
 
-            return self.analysis_data
+    def analyze_dependencies(self, owner, repo, max_files=100):
+        """Analyze code dependencies across the repository."""
+        # Get Python and JavaScript files
+        text_files = self.get_all_text_files(owner, repo, max_files=max_files)
 
-        except Exception as e:
-            raise Exception(f"Error analyzing repository: {str(e)}")
-
-    def _analyze_structure(self) -> Dict[str, Any]:
-        """Analyze repository structure and organization"""
-        structure = {
-            "files": defaultdict(int),
-            "directories": set(),
-            "total_size": 0,
+        # Filter for Python and JS/TS files
+        code_files = [f for f in text_files if f["name"].endswith(('.py', '.js', '.ts', '.jsx', '.tsx'))]
+
+        # Track dependencies
+        dependencies = {
+            'internal': defaultdict(set),  # File to file dependencies
+            'external': defaultdict(set),  # External package dependencies by file
+            'modules': defaultdict(set)    # Defined modules/components by file
         }
 
-        try:
-            contents = self.repo.get_contents("")
-            while contents:
-                content = contents.pop(0)
-                if content.type == "dir":
-                    structure["directories"].add(content.path)
-                    contents.extend(self.repo.get_contents(content.path))
+        # Extract module names from file paths
+        file_to_module = {}
+        for file in code_files:
+            # Convert file path to potential module name
+            module_path = os.path.splitext(file["path"])[0].replace('/', '.')
+            file_to_module[file["path"]] = module_path
+
+            # Track what each file defines
+            summary = self.extract_code_summary(file["content"], file["path"])
+
+            if file["name"].endswith('.py'):
+                for function in summary.get("functions", []):
+                    dependencies['modules'][file["path"]].add(f"{module_path}.{function}")
+                for class_name in summary.get("classes", []):
+                    dependencies['modules'][file["path"]].add(f"{module_path}.{class_name}")
+            else:  # JS/TS files
+                for export in summary.get("exports", []):
+                    dependencies['modules'][file["path"]].add(export)
+
+        # Analyze imports/dependencies
+        for file in code_files:
+            summary = self.extract_code_summary(file["content"], file["path"])
+
+            for imp in summary.get("imports", []):
+                # Check if this is an internal import
+                is_internal = False
+
+                if file["name"].endswith('.py'):
+                    # For Python, check if the import matches any module path
+                    for module_path in file_to_module.values():
+                        if imp == module_path or imp.startswith(f"{module_path}."):
+                            is_internal = True
+                            # Find the file that defines this module
+                            for f_path, m_path in file_to_module.items():
+                                if m_path == imp.split('.')[0]:
+                                    dependencies['internal'][file["path"]].add(f_path)
+                                    break
                 else:
-                    ext = Path(content.path).suffix.lower()
-                    if ext in RELEVANT_EXTENSIONS:
-                        structure["files"][ext] += 1
-                        structure["total_size"] += content.size
-        except Exception as e:
-            print(f"Error analyzing structure: {str(e)}")
+                    # For JS/TS, check relative imports
+                    if imp.startswith('./') or imp.startswith('../'):
+                        is_internal = True
+                        # Try to resolve the relative import
+                        src_dir = os.path.dirname(file["path"])
+                        target_path = os.path.normpath(os.path.join(src_dir, imp))
+
+                        # Add known extensions if not specified
+                        if '.' not in os.path.basename(target_path):
+                            for ext in ['.js', '.ts', '.jsx', '.tsx']:
+                                test_path = f"{target_path}{ext}"
+                                if test_path in file_to_module:
+                                    dependencies['internal'][file["path"]].add(test_path)
+                                    break
+
+                # If not internal, consider it external
+                if not is_internal:
+                    # Clean up the import name (remove relative path parts)
+                    if not file["name"].endswith('.py'):
+                        imp = imp.split('/')[0]  # Take the package name part
+                    dependencies['external'][file["path"]].add(imp)
+
+        return dependencies
+
+    def create_dependency_graph(self, dependencies):
+        """Create a NetworkX graph from dependencies for visualization."""
+        G = nx.DiGraph()
+
+        # Add nodes for files
+        for file_path in dependencies['internal'].keys():
+            G.add_node(file_path, type='file')
+
+        # Add edges for internal dependencies
+        for file_path, deps in dependencies['internal'].items():
+            for dep in deps:
+                G.add_edge(file_path, dep)
+
+        # Add nodes and edges for external dependencies
+        external_nodes = set()
+        for file_path, deps in dependencies['external'].items():
+            for dep in deps:
+                external_node = f"ext:{dep}"
+                if external_node not in external_nodes:
+                    G.add_node(external_node, type='external')
+                    external_nodes.add(external_node)
+                G.add_edge(file_path, external_node)
+
+        return G
+    # ... ( get_repo_text_summary, get_temporal_analysis, get_all_info, ...)
+    def get_repo_text_summary(self, owner, repo, max_files=25):
+        """Extract and summarize text content from the repository with improved metrics."""
+        # Get README
+        readme = self.get_readme(owner, repo)
+
+        # Get documentation
+        docs = self.get_documentation_files(owner, repo)
+
+        # Get key code files (limit to avoid API rate limits)
+        text_files = self.get_all_text_files(owner, repo, max_files=max_files)
+
+        # Analyze code files
+        code_summary = {}
+        complexity_metrics = {
+            'cyclomatic_complexity': [],
+            'maintainability_index': [],
+            'comment_ratios': []
+        }
+
+        for file in text_files:
+            ext = os.path.splitext(file["name"])[1].lower()
+            if ext in ['.py', '.js', '.ts', '.jsx', '.tsx']:
+                file_summary = self.extract_code_summary(file["content"], file["path"])
+                code_summary[file["path"]] = file_summary
+
+                # Collect complexity metrics
+                if file_summary.get('complexity'):
+                    cc = file_summary['complexity'].get('overall')
+                    if cc is not None:
+                        complexity_metrics['cyclomatic_complexity'].append((file["path"], cc))
+
+                    mi = file_summary['complexity'].get('maintainability_index')
+                    if mi is not None:
+                        complexity_metrics['maintainability_index'].append((file["path"], mi))
+
+                if file_summary.get('metrics'):
+                    comment_ratio = file_summary['metrics'].get('comment_ratio', 0)
+                    complexity_metrics['comment_ratios'].append((file["path"], comment_ratio))
+
+        # Analyze dependencies
+        dependencies = self.analyze_dependencies(owner, repo, max_files=max_files)
+
+        # Summarize repository content by file type
+        file_types = defaultdict(int)
+        for file in text_files:
+            ext = os.path.splitext(file["name"])[1].lower()
+            file_types[ext] += 1
+
+        # Calculate aggregate code metrics
+        total_code_lines = sum(summary.get('metrics', {}).get('code_lines', 0)
+                              for summary in code_summary.values())
+        total_comment_lines = sum(summary.get('metrics', {}).get('comment_lines', 0)
+                                 for summary in code_summary.values())
+
+        aggregate_metrics = {
+            'total_files': len(text_files),
+            'total_code_lines': total_code_lines,
+            'total_comment_lines': total_comment_lines,
+            'average_comment_ratio': (total_comment_lines / total_code_lines) if total_code_lines > 0 else 0
+        }
 
         return {
-            "file_types": dict(structure["files"]),
-            "directory_count": len(structure["directories"]),
-            "total_size": structure["total_size"],
-            "file_count": sum(structure["files"].values())
+            "readme": readme,
+            "documentation": docs,
+            "code_summary": code_summary,
+            "complexity_metrics": complexity_metrics,
+            "dependencies": dependencies,
+            "file_type_counts": dict(file_types),
+            "aggregate_metrics": aggregate_metrics,
+            "text_files": text_files  # Include the actual text file contents
         }
 
-    def _analyze_code_patterns(self) -> Dict[str, Any]:
-        """Analyze code patterns and style"""
-        patterns = {
-            "samples": [],
-            "languages": defaultdict(int),
-            "complexity_metrics": defaultdict(list)
+    def get_temporal_analysis(self, owner, repo):
+        """Perform temporal analysis of repository activity."""
+        # Get commit activity over time
+        commit_activity = self.get_commit_activity(owner, repo)
+
+        # Get code frequency (additions/deletions over time)
+        code_frequency = self.get_code_frequency(owner, repo)
+
+        # Get contributor activity
+        contributor_activity = self.get_contributor_activity(owner, repo)
+
+        # Get issue and PR timelines
+        issue_timeline = self.get_issue_timeline(owner, repo)
+        pr_timeline = self.get_pr_timeline(owner, repo)
+
+        # Process data for visualization
+        # - Weekly commit counts
+        weekly_commits = []
+        if commit_activity:
+            for week in commit_activity:
+                date = datetime.fromtimestamp(week['week'])
+                weekly_commits.append({
+                    'date': date.strftime('%Y-%m-%d'),
+                    'total': week['total'],
+                    'days': week['days']  # Daily breakdown within the week
+                })
+
+        # - Weekly code changes
+        weekly_code_changes = []
+        if code_frequency:
+            for item in code_frequency:
+                date = datetime.fromtimestamp(item[0])
+                weekly_code_changes.append({
+                    'date': date.strftime('%Y-%m-%d'),
+                    'additions': item[1],
+                    'deletions': -item[2]  # Convert to positive for visualization
+                })
+
+        # - Contributor timeline
+        contributor_timeline = {}
+        if contributor_activity:
+            for contributor in contributor_activity:
+                author = contributor['author']['login']
+                weeks = contributor['weeks']
+
+                if author not in contributor_timeline:
+                    contributor_timeline[author] = []
+
+                for week in weeks:
+                    if week['c'] > 0:  # Only include weeks with commits
+                        date = datetime.fromtimestamp(week['w'])
+                        contributor_timeline[author].append({
+                            'date': date.strftime('%Y-%m-%d'),
+                            'commits': week['c'],
+                            'additions': week['a'],
+                            'deletions': week['d']
+                        })
+
+        return {
+            'weekly_commits': weekly_commits,
+            'weekly_code_changes': weekly_code_changes,
+            'contributor_timeline': contributor_timeline,
+            'issue_timeline': issue_timeline,
+            'pr_timeline': pr_timeline
         }
 
-        try:
-            files = self.repo.get_contents("")
-            analyzed = 0
-
-            while files and analyzed < 5:
-                file = files.pop(0)
-                if file.type == "dir":
-                    files.extend(self.repo.get_contents(file.path))
-                elif Path(file.path).suffix.lower() in RELEVANT_EXTENSIONS:
-                    try:
-                        content = base64.b64decode(file.content).decode('utf-8')
-                        lines = content.splitlines()
+    def get_all_info(self, owner, repo):
+        """Get comprehensive information about a repository with enhanced metrics."""
+        result = {
+            "timestamp": datetime.now().isoformat(),
+            "basic_info": self.get_repo_info(owner, repo)
+        }
 
-                        if not lines:
-                            continue
+        if not result["basic_info"]:
+            print(f"Could not retrieve repository information for {owner}/{repo}")
+            return None
+
+        print("Getting repository statistics...")
+
+        # Get additional information
+        result["languages"] = self.get_languages(owner, repo)
+        result["contributors"] = self.get_contributors(owner, repo, max_contributors=30)
+        result["recent_commits"] = self.get_commits(owner, repo, max_commits=30)
+        result["branches"] = self.get_branches(owner, repo)
+        result["releases"] = self.get_releases(owner, repo, max_releases=10)
+        result["open_issues"] = self.get_issues(owner, repo, state="open", max_issues=50)
+        result["open_pull_requests"] = self.get_pull_requests(owner, repo, state="open", max_prs=50)
+        result["root_contents"] = self.get_contents(owner, repo)
+
+        print("Analyzing repository content...")
+
+        # Get text content and documentation
+        result["text_content"] = self.get_repo_text_summary(owner, repo, max_files=30)
+
+        print("Analyzing repository activity over time...")
+
+        # Get temporal analysis
+        result["temporal_analysis"] = self.get_temporal_analysis(owner, repo)
+
+        return result
+    # ... ( display_repo_info, display_code_files, export_repo_text )
+
+    def display_repo_info(self, repo_data):
+        """Display repository information in a Colab-friendly format with enhanced visualizations."""
+        if not repo_data or not repo_data["basic_info"]:
+            return
+
+        basic = repo_data["basic_info"]
+
+        # Display basic repository information
+        display(HTML(f"""
+        <h1 style="text-align:center;">Repository: {basic['full_name']}</h1>
+        <div style="text-align:center;"><img src="{basic.get('owner', {}).get('avatar_url', '')}" width="100" height="100" style="border-radius:50%"></div>
+        <div style="background-color:#f5f5f5; padding:15px; border-radius:5px; margin:10px 0;">
+            <p><strong>Description:</strong> {basic['description'] or 'No description'}</p>
+            <p><strong>URL:</strong> <a href="{basic['html_url']}" target="_blank">{basic['html_url']}</a></p>
+            <p><strong>Created:</strong> {basic['created_at']}</p>
+            <p><strong>Last updated:</strong> {basic['updated_at']}</p>
+            <p><strong>Default branch:</strong> {basic['default_branch']}</p>
+            <p><strong>Stars:</strong> {basic['stargazers_count']}</p>
+            <p><strong>Forks:</strong> {basic['forks_count']}</p>
+            <p><strong>Open issues:</strong> {basic['open_issues_count']}</p>
+            <p><strong>License:</strong> {basic['license']['name'] if basic.get('license') else 'Not specified'}</p>
+            <p><strong>Topics:</strong> {', '.join(basic.get('topics', ['None']))}</p>
+        </div>
+        """))
+
+        # Display language distribution
+        if repo_data["languages"]:
+            display(Markdown("## Languages"))
+
+            # Create DataFrame for languages
+            lang_data = []
+            total = sum(repo_data["languages"].values())
+            for lang, bytes_count in repo_data["languages"].items():
+                percentage = (bytes_count / total) * 100
+                lang_data.append({
+                    "Language": lang,
+                    "Bytes": bytes_count,
+                    "Percentage": percentage
+                })
 
-                        loc = len([line for line in lines if line.strip()])
-                        avg_line_length = sum(len(line) for line in lines) / len(lines)
+            lang_df = pd.DataFrame(lang_data)
+            display(lang_df)
+
+            # Create pie chart
+            plt.figure(figsize=(10, 6))
+            plt.pie(lang_df["Percentage"], labels=lang_df["Language"], autopct='%1.1f%%')
+            plt.title("Language Distribution")
+            plt.axis('equal')
+            plt.show()
+
+        # Display contributors
+        if repo_data["contributors"]:
+            display(Markdown("## Top Contributors"))
+
+            # Create DataFrame for contributors
+            contrib_data = []
+            for contributor in repo_data["contributors"][:15]:
+                contrib_data.append({
+                    "Username": contributor['login'],
+                    "Contributions": contributor['contributions'],
+                    "Profile": contributor['html_url']
+                })
 
-                        patterns["samples"].append({
-                            "path": file.path,
-                            "language": Path(file.path).suffix[1:],
-                            "loc": loc,
-                            "avg_line_length": round(avg_line_length, 2)
-                        })
+            contrib_df = pd.DataFrame(contrib_data)
+            display(contrib_df)
+
+            # Create bar chart
+            plt.figure(figsize=(12, 6))
+            plt.bar(contrib_df["Username"], contrib_df["Contributions"])
+            plt.title("Top Contributors")
+            plt.xlabel("Contributor")
+            plt.ylabel("Number of Contributions")
+            plt.xticks(rotation=45, ha='right')
+            plt.tight_layout()
+            plt.show()
+
+        # Display recent commits
+        if repo_data["recent_commits"]:
+            display(Markdown("## Recent Commits"))
+
+            commit_data = []
+            for commit in repo_data["recent_commits"][:10]:
+                author = commit['commit']['author']['name']
+                message = commit['commit']['message'].split('\n')[0]  # First line only
+                date = commit['commit']['author']['date']
+                commit_data.append({
+                    "Author": author,
+                    "Date": date,
+                    "Message": message,
+                    "URL": commit.get('html_url', '')
+                })
 
-                        patterns["languages"][Path(file.path).suffix[1:]] += loc
-                        patterns["complexity_metrics"]["loc"].append(loc)
-                        patterns["complexity_metrics"]["avg_line_length"].append(avg_line_length)
+            commit_df = pd.DataFrame(commit_data)
+            display(commit_df)
 
-                        analyzed += 1
+        # Display repository structure
+        if repo_data["root_contents"]:
+            display(Markdown("## Repository Structure"))
 
-                    except Exception as e:
-                        print(f"Error analyzing file {file.path}: {str(e)}")
+            dir_content = []
+            for item in repo_data["root_contents"]:
+                dir_content.append({
+                    "Name": item["name"],
+                    "Type": item["type"],
+                    "Size": item.get("size", ""),
+                    "URL": item.get("html_url", "")
+                })
+
+            dir_df = pd.DataFrame(dir_content)
+            display(dir_df)
+
+        # Display README preview if available
+        if repo_data["text_content"]["readme"]:
+            display(Markdown("## README Preview"))
+
+            readme = repo_data["text_content"]["readme"]
+            display(Markdown(f"**{readme['name']}**"))
+
+            # Show a preview of the README content (first few lines)
+            lines = readme["content"].split("\n")
+            preview_lines = lines[:min(15, len(lines))]
+            preview = "\n".join(preview_lines)
+
+            display(Markdown(preview))
+            if len(lines) > 15:
+                display(Markdown("*... (content truncated)* ..."))
+
+        # Display code summary
+        if repo_data["text_content"]["code_summary"]:
+            display(Markdown("## Code Summary"))
+
+            # Count total functions and classes
+            total_functions = sum(len(summary.get("functions", [])) for summary in repo_data["text_content"]["code_summary"].values())
+            total_classes = sum(len(summary.get("classes", [])) for summary in repo_data["text_content"]["code_summary"].values())
+
+            # Get aggregate metrics
+            agg_metrics = repo_data["text_content"]["aggregate_metrics"]
+
+            display(HTML(f"""
+            <div style="background-color:#e8f4f8; padding:15px; border-radius:5px; margin:10px 0;">
+                <p><strong>Total Files Analyzed:</strong> {agg_metrics['total_files']}</p>
+                <p><strong>Total Code Lines:</strong> {agg_metrics['total_code_lines']}</p>
+                <p><strong>Total Comment Lines:</strong> {agg_metrics['total_comment_lines']}</p>
+                <p><strong>Comment Ratio:</strong> {agg_metrics['average_comment_ratio']:.2f}</p>
+                <p><strong>Total Functions:</strong> {total_functions}</p>
+                <p><strong>Total Classes:</strong> {total_classes}</p>
+            </div>
+            """))
+
+            # Display complexity metrics
+            if repo_data["text_content"]["complexity_metrics"]["cyclomatic_complexity"]:
+                display(Markdown("### Code Complexity"))
+
+                # Get top 10 most complex files
+                complexity_data = repo_data["text_content"]["complexity_metrics"]["cyclomatic_complexity"]
+                complexity_data.sort(key=lambda x: x[1], reverse=True)
+
+                complex_files = []
+                for path, cc in complexity_data[:10]:
+                    complex_files.append({
+                        "File": os.path.basename(path),
+                        "Path": path,
+                        "Cyclomatic Complexity": cc
+                    })
+
+                complex_df = pd.DataFrame(complex_files)
+                display(complex_df)
+
+                # Plot complexity distribution - ensure we have numeric values only
+                cc_values = []
+                for _, cc in complexity_data:
+                    try:
+                        # Handle both direct numbers and lists that might contain complexity values
+                        if isinstance(cc, (int, float)):
+                            cc_values.append(float(cc))
+                        elif isinstance(cc, list) and len(cc) > 0:
+                            # If it's a list, use the first numeric value
+                            for val in cc:
+                                if isinstance(val, (int, float)):
+                                    cc_values.append(float(val))
+                                    break
+                    except (ValueError, TypeError):
+                        # Skip values that can't be converted to float
                         continue
+                if cc_values:  # Only plot if we have data
+                    plt.figure(figsize=(10, 6))
+                    plt.hist(cc_values, bins=10, alpha=0.7)
+                    plt.title("Cyclomatic Complexity Distribution")
+                    plt.xlabel("Complexity")
+                    plt.ylabel("Number of Files")
+                    plt.axvline(np.mean(cc_values), color='r', linestyle='dashed', linewidth=1, label=f"Mean: {np.mean(cc_values):.2f}")
+                    plt.legend()
+                    plt.tight_layout()
+                    plt.show()
+
+            # Display maintainability index if available
+            if repo_data["text_content"]["complexity_metrics"]["maintainability_index"]:
+                mi_data = repo_data["text_content"]["complexity_metrics"]["maintainability_index"]
+                # Ensure we have numeric values only
+                mi_values = [float(mi) for _, mi in mi_data if mi is not None]
+
+                if mi_values:  # Only plot if we have data
+                    plt.figure(figsize=(10, 6))
+                    plt.hist(mi_values, bins=10, alpha=0.7)
+                    plt.title("Maintainability Index Distribution")
+                    plt.xlabel("Maintainability Index (higher is better)")
+                    plt.ylabel("Number of Files")
+                    plt.axvline(np.mean(mi_values), color='g', linestyle='dashed', linewidth=1, label=f"Mean: {np.mean(mi_values):.2f}")
+                    plt.legend()
+                    plt.tight_layout()
+                    plt.show()
+
+            # Display file type distribution
+            if repo_data["text_content"]["file_type_counts"]:
+                display(Markdown("### File Type Distribution"))
+
+                file_type_data = []
+                for ext, count in repo_data["text_content"]["file_type_counts"].items():
+                    if ext:  # Skip empty extensions
+                        file_type_data.append({
+                            "Extension": ext,
+                            "Count": count
+                        })
 
-        except Exception as e:
-            print(f"Error in code pattern analysis: {str(e)}")
+                file_type_df = pd.DataFrame(file_type_data)
+                display(file_type_df)
+
+                # Create bar chart
+                plt.figure(figsize=(10, 6))
+                plt.bar(file_type_df["Extension"], file_type_df["Count"])
+                plt.title("File Type Distribution")
+                plt.xlabel("File Extension")
+                plt.ylabel("Count")
+                plt.xticks(rotation=45, ha='right')
+                plt.tight_layout()
+                plt.show()
+
+        # Display dependency graph if available
+        if repo_data["text_content"]["dependencies"]:
+            display(Markdown("## Code Dependencies"))
+
+            # Create dependency graph
+            G = self.create_dependency_graph(repo_data["text_content"]["dependencies"])
+
+            # Display dependency statistics
+            internal_deps = repo_data["text_content"]["dependencies"]["internal"]
+            external_deps = repo_data["text_content"]["dependencies"]["external"]
+
+            # Count unique external dependencies
+            all_external = set()
+            for deps in external_deps.values():
+                all_external.update(deps)
+
+            # Find most imported packages
+            ext_counts = Counter()
+            for deps in external_deps.values():
+                ext_counts.update(deps)
+
+            top_imports = ext_counts.most_common(10)
+
+            display(HTML(f"""
+            <div style="background-color:#e8f4f8; padding:15px; border-radius:5px; margin:10px 0;">
+                <p><strong>Files with Dependencies:</strong> {len(internal_deps) + len(external_deps)}</p>
+                <p><strong>Internal Dependency Relationships:</strong> {sum(len(deps) for deps in internal_deps.values())}</p>
+                <p><strong>Unique External Dependencies:</strong> {len(all_external)}</p>
+            </div>
+            """))
+
+            # Display most imported packages
+            if top_imports:
+                display(Markdown("### Most Used External Dependencies"))
+
+                imports_data = []
+                for pkg, count in top_imports:
+                    imports_data.append({
+                        "Package": pkg,
+                        "Used in # Files": count
+                    })
+
+                imports_df = pd.DataFrame(imports_data)
+                display(imports_df)
+
+            # Visualize dependency network (if not too large)
+            if len(G.nodes) <= 50:  # Only visualize if not too complex
+                try:
+                    display(Markdown("### Dependency Network"))
+
+                    plt.figure(figsize=(12, 12))
+
+                    # Node colors based on type
+                    node_colors = []
+                    for node in G.nodes:
+                        if G.nodes[node].get('type') == 'external':
+                            node_colors.append('red')
+                        else:
+                            node_colors.append('skyblue')
+
+                    # Node sizes based on connections
+                    node_sizes = [100 + 50 * G.degree(node) for node in G.nodes]
+
+                    # Layout for the graph
+                    pos = nx.spring_layout(G, k=0.5, iterations=50, seed=42)  # Adding seed for reproducibility
+
+                    # Draw the graph
+                    nx.draw_networkx(
+                        G, pos,
+                        with_labels=False,
+                        node_color=node_colors,
+                        node_size=node_sizes,
+                        alpha=0.7,
+                        arrows=True,
+                        arrowsize=10,
+                        width=0.5
+                    )
+
+                    # Add labels for external dependencies
+                    external_labels = {node: node.replace('ext:', '')
+                                    for node in G.nodes
+                                    if G.nodes[node].get('type') == 'external'}
+
+                    nx.draw_networkx_labels(
+                        G, pos,
+                        labels=external_labels,
+                        font_size=8,
+                        font_color='black'
+                    )
+
+                    plt.title("Code Dependency Network (red=external)")
+                    plt.axis('off')
+                    plt.tight_layout()
+                    plt.show()
+                except Exception as e:
+                    print(f"Error generating dependency network visualization: {str(e)}")
+                    print("Skipping network visualization due to data compatibility issues.")
 
-        return patterns
+        # Display temporal analysis
+        if repo_data["temporal_analysis"]["weekly_commits"]:
+            display(Markdown("## Repository Activity Over Time"))
 
-    def _analyze_commits(self) -> Dict[str, Any]:
-        """Analyze commit history and patterns"""
-        commit_data = []
-        commit_times = []
+            # Commit activity over time
+            weekly_commits = repo_data["temporal_analysis"]["weekly_commits"]
+            if weekly_commits:
+                display(Markdown("### Weekly Commit Activity"))
 
-        try:
-            commits = list(self.repo.get_commits()[:100])  # Get last 100 commits
+                # Convert to DataFrame for plotting
+                dates = [datetime.strptime(week['date'], '%Y-%m-%d') for week in weekly_commits]
+                commits = [week['total'] for week in weekly_commits]
 
-            for commit in commits:
                 try:
-                    commit_info = {
-                        "sha": commit.sha,
-                        "author": commit.author.login if commit.author else "Unknown",
-                        "date": commit.commit.author.date.isoformat(),
-                        "message": commit.commit.message,
-                        "changes": {
-                            "additions": commit.stats.additions,
-                            "deletions": commit.stats.deletions,
-                        }
-                    }
-                    commit_data.append(commit_info)
-                    commit_times.append(commit.commit.author.date.hour)
+                    plt.figure(figsize=(14, 6))
+                    plt.plot(dates, commits, marker='o', linestyle='-', alpha=0.7)
+                    plt.title("Weekly Commit Activity")
+                    plt.xlabel("Date")
+                    plt.ylabel("Number of Commits")
+                    plt.grid(True, alpha=0.3)
+
+                    # Format x-axis to show dates nicely
+                    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
+                    plt.gca().xaxis.set_major_locator(mdates.MonthLocator(interval=1))
+                    plt.gcf().autofmt_xdate()
+
+                    plt.tight_layout()
+                    plt.show()
                 except Exception as e:
-                    print(f"Error processing commit {commit.sha}: {str(e)}")
-                    continue
+                    print(f"Error generating commit activity chart: {str(e)}")
+                    print("Displaying raw data instead:")
+                    activity_df = pd.DataFrame({
+                        'Date': [week['date'] for week in weekly_commits],
+                        'Commits': [week['total'] for week in weekly_commits]
+                    })
+                    display(activity_df.head(10))
+
+            # Code changes over time
+            weekly_code_changes = repo_data["temporal_analysis"]["weekly_code_changes"]
+            if weekly_code_changes:
+                display(Markdown("### Weekly Code Changes"))
+
+                # Convert to DataFrame for plotting
+                dates = [datetime.strptime(week['date'], '%Y-%m-%d') for week in weekly_code_changes]
+                additions = [week['additions'] for week in weekly_code_changes]
+                deletions = [week['deletions'] for week in weekly_code_changes]
 
-            # Analyze commit patterns
-            commit_hours = defaultdict(int)
-            for hour in commit_times:
-                commit_hours[hour] += 1
+                try:
+                    # Convert data to proper format for plotting
+                    plot_dates = np.array(dates)
+                    plot_additions = np.array([float(a) for a in additions])
+                    plot_deletions = np.array([float(d) for d in deletions])
+
+                    plt.figure(figsize=(14, 6))
+                    plt.bar(plot_dates, plot_additions, color='green', alpha=0.6, label='Additions')
+                    plt.bar(plot_dates, plot_deletions, color='red', alpha=0.6, label='Deletions')
+                    plt.title("Weekly Code Changes")
+                    plt.xlabel("Date")
+                    plt.ylabel("Lines Changed")
+                    plt.legend()
+
+                    # Format x-axis to show dates nicely
+                    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y-%m-%d'))
+                    plt.gca().xaxis.set_major_locator(mdates.MonthLocator(interval=1))
+                    plt.gcf().autofmt_xdate()
+
+                    plt.tight_layout()
+                    plt.show()
+                except Exception as e:
+                    print(f"Error generating code changes chart: {str(e)}")
+                    print("Displaying raw data instead:")
+                    changes_df = pd.DataFrame({
+                        'Date': [week['date'] for week in weekly_code_changes],
+                        'Additions': [week['additions'] for week in weekly_code_changes],
+                        'Deletions': [week['deletions'] for week in weekly_code_changes]
+                    })
+                    display(changes_df.head(10))
+
+            # Display issue resolution metrics
+            issue_timeline = repo_data["temporal_analysis"]["issue_timeline"]
+            if issue_timeline and issue_timeline.get('resolution_times'):
+                display(Markdown("### Issue Resolution Statistics"))
+
+                resolution_times = issue_timeline['resolution_times']
+
+                if resolution_times:
+                    # Calculate statistics
+                    avg_resolution = np.mean(resolution_times)
+                    median_resolution = np.median(resolution_times)
+
+                    display(HTML(f"""
+                    <div style="background-color:#f5f5f5; padding:15px; border-radius:5px; margin:10px 0;">
+                        <p><strong>Average Time to Close Issues:</strong> {avg_resolution:.2f} hours ({avg_resolution/24:.2f} days)</p>
+                        <p><strong>Median Time to Close Issues:</strong> {median_resolution:.2f} hours ({median_resolution/24:.2f} days)</p>
+                        <p><strong>Issues Analyzed:</strong> {len(resolution_times)}</p>
+                    </div>
+                    """))
+
+                    # Plot histogram of resolution times
+                    try:
+                        plt.figure(figsize=(10, 6))
+                        # Ensure all values are float and clip to reasonable range
+                        resolution_times_clean = np.array([float(rt) for rt in resolution_times if rt is not None])
+                        plt.hist(np.clip(resolution_times_clean, 0, 168), bins=20, alpha=0.7)  # Clip to one week for readability
+                        plt.title("Issue Resolution Times (Capped at 1 Week)")
+                        plt.xlabel("Hours to Resolution")
+                        plt.ylabel("Number of Issues")
+                        plt.axvline(avg_resolution, color='r', linestyle='dashed', linewidth=1, label=f"Mean: {avg_resolution:.2f} hours")
+                        plt.axvline(median_resolution, color='g', linestyle='dashed', linewidth=1, label=f"Median: {median_resolution:.2f} hours")
+                        plt.legend()
+                        plt.tight_layout()
+                        plt.show()
+                    except Exception as e:
+                        print(f"Error generating issue resolution histogram: {str(e)}")
+                        print("Skipping histogram visualization due to data compatibility issues.")
+
+                # Display issue labels analysis
+                if issue_timeline.get('labels'):
+                    top_labels = sorted(issue_timeline['labels'].items(), key=lambda x: x[1], reverse=True)[:10]
+
+                    if top_labels:
+                        display(Markdown("### Top Issue Labels"))
+
+                        labels = [label for label, _ in top_labels]
+                        counts = [count for _, count in top_labels]
+
+                        try:
+                            plt.figure(figsize=(10, 6))
+
+                            # Limit label length for display and handle potential non-string labels
+                            cleaned_labels = []
+                            for label in labels:
+                                if isinstance(label, str):
+                                    # Truncate long labels
+                                    if len(label) > 20:
+                                        cleaned_labels.append(label[:17] + "...")
+                                    else:
+                                        cleaned_labels.append(label)
+                                else:
+                                    # Convert non-string labels to string
+                                    cleaned_labels.append(str(label))
+
+                            plt.bar(cleaned_labels, counts, alpha=0.7)
+                            plt.title("Most Common Issue Labels")
+                            plt.xlabel("Label")
+                            plt.ylabel("Count")
+                            plt.xticks(rotation=45, ha='right')
+                            plt.tight_layout()
+                            plt.show()
+                        except Exception as e:
+                            print(f"Error generating issue labels chart: {str(e)}")
+                            print("Skipping labels visualization due to data compatibility issues.")
+
+            # Display PR statistics
+            pr_timeline = repo_data["temporal_analysis"]["pr_timeline"]
+            if pr_timeline:
+                display(Markdown("### Pull Request Statistics"))
+
+                # Display PR acceptance rate
+                acceptance_rate = pr_timeline.get('acceptance_rate', 0)
+
+                display(HTML(f"""
+    <div style="background-color:#2c2c2c; color:#f5f5f5; padding:15px; border-radius:8px; margin:10px 0;">
+        <p><strong>PR Acceptance Rate:</strong> {acceptance_rate:.2f}%</p>
+    </div>
+    """))
+
+                # Display PR merge time statistics
+                if pr_timeline.get('merge_times'):
+                    merge_times = pr_timeline['merge_times']
+
+                    if merge_times:
+                        avg_merge = np.mean(merge_times)
+                        median_merge = np.median(merge_times)
+
+                        display(HTML(f"""
+                        <div style="background-color:#2c2c2c; color:#f5f5f5; padding:15px; border-radius:8px; margin:10px 0;">
+                            <p><strong>Average Time to Merge PRs:</strong> {avg_merge:.2f} hours ({avg_merge/24:.2f} days)</p>
+                            <p><strong>Median Time to Merge PRs:</strong> {median_merge:.2f} hours ({median_merge/24:.2f} days)</p>
+                            <p><strong>PRs Analyzed:</strong> {len(merge_times)}</p>
+                        </div>
+                        """))
+
+                        # Plot histogram of merge times
+                        try:
+                            plt.figure(figsize=(10, 6))
+                            # Ensure all values are float and clip to reasonable range
+                            merge_times_clean = np.array([float(mt) for mt in merge_times if mt is not None])
+                            plt.hist(np.clip(merge_times_clean, 0, 168), bins=20, alpha=0.7)  # Clip to one week for readability
+                            plt.title("PR Merge Times (Capped at 1 Week)")
+                            plt.xlabel("Hours to Merge")
+                            plt.ylabel("Number of PRs")
+                            plt.axvline(avg_merge, color='r', linestyle='dashed', linewidth=1, label=f"Mean: {avg_merge:.2f} hours")
+                            plt.axvline(median_merge, color='g', linestyle='dashed', linewidth=1, label=f"Median: {median_merge:.2f} hours")
+                            plt.legend()
+                            plt.tight_layout()
+                            plt.show()
+                        except Exception as e:
+                            print(f"Error generating PR merge time histogram: {str(e)}")
+                            print("Skipping histogram visualization due to data compatibility issues.")
+
+    def display_code_files(self, repo_data, max_files=5):
+        """Display code files with syntax highlighting and complexity metrics."""
+        if not repo_data or not repo_data["text_content"] or not repo_data["text_content"]["text_files"]:
+            return
+
+        display(Markdown("## Code File Preview"))
+
+        # Filter for Python/JavaScript/TypeScript files
+        code_files = [
+            file for file in repo_data["text_content"]["text_files"]
+            if file["name"].endswith(('.py', '.js', '.ts', '.jsx', '.tsx'))
+        ]
+
+        # Sort by complexity if available
+        complexity_metrics = repo_data["text_content"]["complexity_metrics"]["cyclomatic_complexity"]
+        complexity_dict = {path: cc for path, cc in complexity_metrics}
+
+        # Sort files by complexity (if available) or by file size
+        if complexity_dict:
+            code_files.sort(key=lambda x: complexity_dict.get(x["path"], 0), reverse=True)
+        else:
+            code_files.sort(key=lambda x: len(x["content"]), reverse=True)
+
+        # Display up to max_files
+        for i, file in enumerate(code_files[:max_files]):
+            file_path = file["path"]
+            complexity = complexity_dict.get(file_path, "N/A")
+
+            display(Markdown(f"### {file_path} (Complexity: {complexity})"))
+
+            # Get code summary
+            summary = repo_data["text_content"]["code_summary"].get(file_path, {})
+
+            # Display functions and classes
+            if summary.get("functions") or summary.get("classes"):
+                func_list = ", ".join(summary.get("functions", []))
+                class_list = ", ".join(summary.get("classes", []))
+
+                display(HTML(f"""
+                <div style="background-color:#2c2c2c; color:#f5f5f5; padding:10px; border-radius:5px; margin:5px 0; font-size:0.9em;">
+                    <p><strong>Functions:</strong> {func_list or "None"}</p>
+                    <p><strong>Classes:</strong> {class_list or "None"}</p>
+                </div>
+                """))
+
+            # Get file extension for syntax highlighting
+            ext = os.path.splitext(file["name"])[1][1:]  # Remove the dot
+
+            # Display code with syntax highlighting (first 100 lines max)
+            code = file["content"]
+            lines = code.split("\n")
+            preview_lines = lines[:min(100, len(lines))]
+            preview = "\n".join(preview_lines)
+
+            display(Markdown(f"```{ext}\n{preview}\n```"))
+
+            if len(lines) > 100:
+                display(Markdown(f"*... ({len(lines) - 100} more lines) ...*"))
+
+    def export_repo_text(self, repo_data, output_dir='/content/repo_text'):
+        """Export repository text content and analysis to files in Colab."""
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        # Write README
+        if repo_data["text_content"]["readme"] and repo_data["text_content"]["readme"].get("content"):
+            readme_path = os.path.join(output_dir, "README.md")
+            with open(readme_path, 'w', encoding='utf-8') as f:
+                f.write(repo_data["text_content"]["readme"]["content"])
+
+        # Write documentation files
+        if repo_data["text_content"]["documentation"]:
+            docs_dir = os.path.join(output_dir, "docs")
+            if not os.path.exists(docs_dir):
+                os.makedirs(docs_dir)
+
+            for doc in repo_data["text_content"]["documentation"]:
+                # Create directory structure if needed
+                doc_path = os.path.join(docs_dir, doc["name"])
+                with open(doc_path, 'w', encoding='utf-8') as f:
+                    f.write(doc["content"])
+
+        # Write code files
+        code_dir = os.path.join(output_dir, "code")
+        if not os.path.exists(code_dir):
+            os.makedirs(code_dir)
+
+        for file in repo_data["text_content"]["text_files"]:
+            if os.path.splitext(file["name"])[1].lower() in ['.py', '.js', '.ts', '.jsx', '.tsx']:
+                file_path = os.path.join(code_dir, file["name"])
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(file["content"])
+
+        # Write enhanced repository summary
+        summary_path = os.path.join(output_dir, "repo_summary.md")
+        with open(summary_path, 'w', encoding='utf-8') as f:
+            # Get basic info
+            basic = repo_data["basic_info"]
+
+            f.write(f"# Repository Summary: {basic['full_name']}\n\n")
+            f.write(f"**Description:** {basic['description'] or 'No description'}\n\n")
+            f.write(f"**URL:** {basic['html_url']}\n")
+            f.write(f"**Created:** {basic['created_at']}\n")
+            f.write(f"**Last updated:** {basic['updated_at']}\n")
+            f.write(f"**Default branch:** {basic['default_branch']}\n")
+            f.write(f"**Stars:** {basic['stargazers_count']}\n")
+            f.write(f"**Forks:** {basic['forks_count']}\n")
+            f.write(f"**Open issues:** {basic['open_issues_count']}\n\n")
+
+            # Analysis timestamp
+            f.write(f"*Analysis performed: {repo_data['timestamp']}*\n\n")
+
+            # Languages
+            if repo_data["languages"]:
+                f.write("## Languages\n\n")
+                total = sum(repo_data["languages"].values())
+                for lang, bytes_count in repo_data["languages"].items():
+                    percentage = (bytes_count / total) * 100
+                    f.write(f"- **{lang}**: {percentage:.1f}% ({bytes_count} bytes)\n")
+                f.write("\n")
+
+            # Contributors
+            if repo_data["contributors"]:
+                f.write("## Top Contributors\n\n")
+                for i, contributor in enumerate(repo_data["contributors"][:10], 1):
+                    f.write(f"{i}. {contributor['login']} - {contributor['contributions']} contributions\n")
+                f.write("\n")
+
+            # Repository Activity
+            if repo_data["temporal_analysis"]["weekly_commits"]:
+                f.write("## Repository Activity\n\n")
+
+                # Recent commit activity
+                recent_weeks = repo_data["temporal_analysis"]["weekly_commits"][-10:]
+                f.write("### Recent Commit Activity\n\n")
+                f.write("| Week | Commits |\n")
+                f.write("|------|--------|\n")
+                for week in recent_weeks:
+                    f.write(f"| {week['date']} | {week['total']} |\n")
+                f.write("\n")
+
+                # Issue and PR stats
+                issue_timeline = repo_data["temporal_analysis"]["issue_timeline"]
+                pr_timeline = repo_data["temporal_analysis"]["pr_timeline"]
+
+                if issue_timeline and issue_timeline.get('resolution_times'):
+                    avg_resolution = np.mean(issue_timeline['resolution_times'])
+                    median_resolution = np.median(issue_timeline['resolution_times'])
+
+                    f.write("### Issue Statistics\n\n")
+                    f.write(f"- Average time to close issues: {avg_resolution:.2f} hours ({avg_resolution/24:.2f} days)\n")
+                    f.write(f"- Median time to close issues: {median_resolution:.2f} hours ({median_resolution/24:.2f} days)\n")
+                    f.write(f"- Issues analyzed: {len(issue_timeline['resolution_times'])}\n\n")
+
+                if pr_timeline and pr_timeline.get('merge_times'):
+                    avg_merge = np.mean(pr_timeline['merge_times'])
+                    median_merge = np.median(pr_timeline['merge_times'])
+
+                    f.write("### Pull Request Statistics\n\n")
+                    f.write(f"- PR acceptance rate: {pr_timeline['acceptance_rate']:.2f}%\n")
+                    f.write(f"- Average time to merge PRs: {avg_merge:.2f} hours ({avg_merge/24:.2f} days)\n")
+                    f.write(f"- Median time to merge PRs: {median_merge:.2f} hours ({median_merge/24:.2f} days)\n")
+                    f.write(f"- PRs analyzed: {len(pr_timeline['merge_times'])}\n\n")
+
+            # Code Complexity
+            if repo_data["text_content"]["complexity_metrics"]["cyclomatic_complexity"]:
+                f.write("## Code Complexity\n\n")
+
+                complexity_data = repo_data["text_content"]["complexity_metrics"]["cyclomatic_complexity"]
+                complexity_data.sort(key=lambda x: x[1], reverse=True)
+
+                f.write("### Most Complex Files\n\n")
+                f.write("| File | Cyclomatic Complexity |\n")
+                f.write("|------|------------------------|\n")
+
+                for path, cc in complexity_data[:10]:
+                    f.write(f"| {path} | {cc} |\n")
+
+                f.write("\n")
+
+                # Get aggregate metrics
+                """
+                cc_values = [cc for _, cc in complexity_data]
+                f.write(f"- **Average complexity**: {np.mean(cc_values):.2f}\n")
+                f.write(f"- **Median complexity**: {np.median(cc_values):.2f}\n")
+                f.write(f"- **Max complexity**: {np.max(cc_values)}\n")
+                f.write(f"- **Files analyzed**: {len(cc_values)}\n\n")
+                """
+                cc_values = []
+                for _, cc in complexity_data:
+                    try:
+                        # Handle different possible types
+                        if isinstance(cc, (int, float)):
+                            cc_values.append(float(cc))
+                        elif isinstance(cc, list) and len(cc) > 0:
+                            # If it's a list, try to get first numeric item
+                            cc_values.append(float(cc[0]))
+                        else:
+                            # Try simple conversion as fallback
+                            cc_values.append(float(cc))
+                    except (ValueError, TypeError):
+                        # Skip this value if conversion fails
+                        continue
+                if cc_values:
+                    f.write(f"- **Average complexity**: {np.mean(cc_values):.2f}\n")
+                    f.write(f"- **Median complexity**: {np.median(cc_values):.2f}\n")
+                    f.write(f"- **Max complexity**: {max(cc_values)}\n")
+                    f.write(f"- **Files analyzed**: {len(cc_values)}\n\n")
+                else:
+                    f.write("- **Complexity metrics**: Could not be calculated\n\n")
+
+            # Code Dependencies
+            if repo_data["text_content"]["dependencies"]:
+                f.write("## Code Dependencies\n\n")
+
+                external_deps = repo_data["text_content"]["dependencies"]["external"]
+
+                # Count unique external dependencies
+                all_external = set()
+                for deps in external_deps.values():
+                    all_external.update(deps)
+
+                # Find most imported packages
+                ext_counts = Counter()
+                for deps in external_deps.values():
+                    ext_counts.update(deps)
+
+                top_imports = ext_counts.most_common(10)
+
+                f.write("### Most Used External Dependencies\n\n")
+                f.write("| Package | Used in # Files |\n")
+                f.write("|---------|----------------|\n")
+
+                for pkg, count in top_imports:
+                    f.write(f"| {pkg} | {count} |\n")
+
+                f.write("\n")
+
+            # Code Summary
+            if repo_data["text_content"]["code_summary"]:
+                f.write("## Code Structure\n\n")
+
+                # Get summary of most significant files
+                complexity_data = repo_data["text_content"]["complexity_metrics"]["cyclomatic_complexity"]
+                complexity_data.sort(key=lambda x: x[1], reverse=True)
+
+                for path, _ in complexity_data[:5]:
+                    summary = repo_data["text_content"]["code_summary"].get(path)
+                    if summary:
+                        f.write(f"### {path}\n\n")
+
+                        if summary.get("description"):
+                            f.write(f"{summary['description']}\n\n")
+
+                        if summary.get("classes"):
+                            f.write("**Classes:**\n\n")
+                            for cls in summary["classes"]:
+                                f.write(f"- `{cls}`\n")
+                            f.write("\n")
+
+                        if summary.get("functions"):
+                            f.write("**Functions:**\n\n")
+                            for func in summary["functions"]:
+                                f.write(f"- `{func}()`\n")
+                            f.write("\n")
+
+                        if summary.get("imports"):
+                            f.write("**Imports:**\n\n")
+                            for imp in summary["imports"][:10]:  # Limit to top 10
+                                if isinstance(imp, tuple):
+                                    imp = ' '.join(filter(None, imp))
+                                f.write(f"- `{imp}`\n")
+                            f.write("\n")
+
+    # --- NEW METHOD for getting specific PR details ---
+    def get_pull_request_details(self, owner, repo, pr_number):
+        """Get detailed information for a specific Pull Request using PyGithub."""
+        if not self.github:
+            print("PyGithub client not initialized. Cannot fetch PR details.")
+            # Fallback maybe? Or just return None
+            # You could try a direct REST call here if needed
+            return None
 
-            total_commits = len(commit_data)
-            return {
-                "commits": commit_data,
-                "total_commits": total_commits,
-                "commit_hours": dict(commit_hours),
-                "avg_additions": sum(c["changes"]["additions"] for c in commit_data) / total_commits if total_commits else 0,
-                "avg_deletions": sum(c["changes"]["deletions"] for c in commit_data) / total_commits if total_commits else 0,
+        try:
+            repo_obj = self.github.get_repo(f"{owner}/{repo}")
+            pr = repo_obj.get_pull(pr_number)
+
+            # Extract relevant information into a dictionary
+            details = {
+                "number": pr.number,
+                "title": pr.title,
+                "state": pr.state, # 'open', 'closed'
+                "merged": pr.merged,
+                "body": pr.body or "", # Ensure body is string
+                "url": pr.html_url,
+                "created_at": pr.created_at.isoformat() if pr.created_at else None,
+                "updated_at": pr.updated_at.isoformat() if pr.updated_at else None,
+                "closed_at": pr.closed_at.isoformat() if pr.closed_at else None,
+                "merged_at": pr.merged_at.isoformat() if pr.merged_at else None,
+                "author": pr.user.login if pr.user else "N/A",
+                "commits_count": pr.commits,
+                "additions": pr.additions,
+                "deletions": pr.deletions,
+                "changed_files_count": pr.changed_files,
+                "labels": [label.name for label in pr.labels],
+                "assignees": [assignee.login for assignee in pr.assignees],
+                "milestone": pr.milestone.title if pr.milestone else None,
+                "repo_full_name": f"{owner}/{repo}", # Add repo context
+                # Add more fields if needed (e.g., comments, reviews)
             }
+            return details
+
+        except GithubException as e:
+            if e.status == 404:
+                print(f"Error: Pull Request #{pr_number} not found in {owner}/{repo}.")
+            else:
+                print(f"Error fetching PR #{pr_number} details: {e}")
+            return None
+        except Exception as e:
+            print(f"An unexpected error occurred fetching PR details: {e}")
+            return None
+
+
+# --- Colab Helpers (Keep these as provided) ---
+try:
+    from google.colab import files
+    IN_COLAB = True
+except ImportError:
+    IN_COLAB = False
+
+# ...(keep download_file and save_json_to_colab functions)...
+class CustomJSONEncoder(json.JSONEncoder):
+        def default(self, obj):
+            if isinstance(obj, set):
+                return list(obj)
+            elif isinstance(obj, (datetime, np.datetime64)):
+                 # Handle both standard datetime and numpy datetime64
+                if isinstance(obj, np.datetime64):
+                     # Convert numpy datetime64 to standard datetime
+                     ts = pd.to_datetime(obj)
+                     return ts.isoformat()
+                return obj.isoformat()
+            elif isinstance(obj, (np.int64, np.int32)):
+                 return int(obj)
+            elif isinstance(obj, (np.float64, np.float32)):
+                 return float(obj)
+            elif hasattr(obj, '__dict__'):
+                 # Be careful with complex objects, might expose too much
+                 # Consider filtering attributes if needed
+                 return {k: v for k, v in obj.__dict__.items() if not k.startswith('_') and not callable(v)}
+            # Let the base class default method raise the TypeError
+            return super(CustomJSONEncoder, self).default(obj)
+
+def convert_sets_to_lists(obj):
+    # Recursive function to convert sets and handle numpy types
+    if isinstance(obj, dict):
+        return {k: convert_sets_to_lists(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_sets_to_lists(i) for i in obj]
+    elif isinstance(obj, set):
+        return [convert_sets_to_lists(i) for i in obj]
+    elif isinstance(obj, tuple):
+        return tuple(convert_sets_to_lists(i) for i in obj)
+    elif isinstance(obj, (np.int64, np.int32)):
+        return int(obj)
+    elif isinstance(obj, (np.float64, np.float32)):
+         return float(obj)
+    elif isinstance(obj, np.datetime64):
+         ts = pd.to_datetime(obj)
+         return ts.isoformat()
+    elif isinstance(obj, np.bool_):
+         return bool(obj)
+    elif isinstance(obj, np.ndarray):
+         return convert_sets_to_lists(obj.tolist()) # Convert numpy arrays to lists
+    else:
+        # Attempt to handle other non-serializable types gracefully
+        try:
+            json.dumps(obj) # Test if serializable
+            return obj
+        except TypeError:
+            return str(obj) # Convert to string as a fallback
+
+def save_json_to_colab(data, filename='/content/repo_info.json'):
+    """Save JSON data to a file in Colab and provide download option."""
+    # ... (rest of the save_json_to_colab function using the above helpers) ...
+    converted_data = convert_sets_to_lists(data)
+    try:
+        with open(filename, 'w') as f:
+            json.dump(converted_data, f, indent=2, cls=CustomJSONEncoder)
+        print(f"Data saved to {filename}")
+        if IN_COLAB:
+            print("To download the JSON file, run the following cell:")
+            print(f"from google.colab import files")
+            print(f"files.download('{filename}')")
+    except TypeError as e:
+        print(f"Error saving JSON: {e}")
+        print("There might be non-serializable data types remaining.")
+    
+# Keep GraphRepoAnalyzer class mostly unchanged
+class GraphRepoAnalyzer:
+    """Integrates GitHub analysis with Neo4j and Gemini."""
+
+    # --- Keep ALL existing methods from the previous version ---
+    # ... ( __init__, close, _create_neo4j_constraints, _run_cypher, ...)
+    def __init__(self, github_token=None, neo4j_uri=None, neo4j_user=None, neo4j_password=None, gemini_api_key=None):
+        """Initialize with credentials."""
+        load_dotenv() # Load .env file if it exists
+
+        self.github_token = github_token or os.getenv("GITHUB_TOKEN")
+        self.neo4j_uri = neo4j_uri or os.getenv("NEO4J_URI")
+        self.neo4j_user = neo4j_user or os.getenv("NEO4J_USERNAME")
+        self.neo4j_password = neo4j_password or os.getenv("NEO4J_PASSWORD")
+        self.gemini_api_key = gemini_api_key or os.getenv("GOOGLE_API_KEY")
+
+        if not all([self.neo4j_uri, self.neo4j_user, self.neo4j_password]):
+            print("Warning: Neo4j credentials not fully provided. Graph features will be disabled.")
+            self.neo4j_driver = None
+        else:
+            try:
+                # Use basic_auth for Neo4j driver authentication
+                self.neo4j_driver = GraphDatabase.driver(self.neo4j_uri, auth=basic_auth(self.neo4j_user, self.neo4j_password))
+                self.neo4j_driver.verify_connectivity()
+                print("Successfully connected to Neo4j.")
+                self._create_neo4j_constraints()
+            except Exception as e:
+                print(f"Error connecting to Neo4j: {e}")
+                print("Graph features will be disabled.")
+                self.neo4j_driver = None
+
+        if not self.gemini_api_key:
+            print("Warning: Google API Key not provided. Gemini features will be disabled.")
+            self.gemini_model = None
+        else:
+            try:
+                genai.configure(api_key=self.gemini_api_key)
+                # Use the latest Gemini 1.5 Pro model
+                self.gemini_model = genai.GenerativeModel('gemini-1.5-pro-latest')
+                print("Gemini 1.5 Pro model initialized.")
+            except Exception as e:
+                print(f"Error initializing Gemini: {e}")
+                self.gemini_model = None
+
+        self.github_analyzer = GitHubRepoInfo(token=self.github_token)
+        self.repo_data = None
+        self.repo_full_name = None # Store repo name for context
+
+    def close(self):
+        """Close the Neo4j driver connection."""
+        if self.neo4j_driver:
+            self.neo4j_driver.close()
+            print("Neo4j connection closed.")
+
+    def _create_neo4j_constraints(self):
+        """Create unique constraints for better performance and data integrity."""
+        if not self.neo4j_driver: return
+        constraints = [
+            "CREATE CONSTRAINT repo_name IF NOT EXISTS FOR (r:Repository) REQUIRE r.fullName IS UNIQUE;",
+            "CREATE CONSTRAINT user_login IF NOT EXISTS FOR (u:User) REQUIRE u.login IS UNIQUE;",
+            "CREATE CONSTRAINT commit_sha IF NOT EXISTS FOR (c:Commit) REQUIRE c.sha IS UNIQUE;",
+            "CREATE CONSTRAINT file_path IF NOT EXISTS FOR (f:File) REQUIRE f.path IS UNIQUE;",
+            "CREATE CONSTRAINT lang_name IF NOT EXISTS FOR (l:Language) REQUIRE l.name IS UNIQUE;",
+            "CREATE CONSTRAINT dep_name IF NOT EXISTS FOR (d:Dependency) REQUIRE d.name IS UNIQUE;",
+            "CREATE CONSTRAINT issue_num IF NOT EXISTS FOR (i:Issue) REQUIRE i.number IS UNIQUE;", # Assumes issue number is unique within repo context - adjust if needed
+            "CREATE CONSTRAINT pr_num IF NOT EXISTS FOR (p:PullRequest) REQUIRE p.number IS UNIQUE;", # Same assumption for PRs
+        ]
+        try:
+            with self.neo4j_driver.session() as session:
+                for constraint in constraints:
+                    session.run(constraint)
+            print("Neo4j constraints ensured.")
+        except Exception as e:
+            print(f"Error creating Neo4j constraints: {e}")
 
+
+    def _run_cypher(self, query, parameters=None):
+        """Helper function to run Cypher queries."""
+        if not self.neo4j_driver:
+            print("Neo4j connection not available.")
+            return None
+        try:
+            with self.neo4j_driver.session() as session:
+                result = session.run(query, parameters)
+                return [record.data() for record in result] # Return results as list of dicts
         except Exception as e:
-            print(f"Error in commit analysis: {str(e)}")
-            return {
-                "commits": [],
-                "total_commits": 0,
-                "commit_hours": {},
-                "avg_additions": 0,
-                "avg_deletions": 0
-            }
+            print(f"Error running Cypher query: {e}")
+            print(f"Query: {query}")
+            print(f"Parameters: {parameters}")
+            return None
+
+    # ... ( _populate_basic_info, _populate_contributors, _populate_commits, ...)
+
+    def _populate_basic_info(self, tx, repo_node, basic_info):
+        """Populate basic repo info and owner."""
+        owner_login = basic_info.get('owner', {}).get('login')
+        if owner_login:
+            tx.run("""
+                MERGE (u:User {login: $owner_login})
+                ON CREATE SET u.avatarUrl = $avatar_url, u.type = $owner_type
+                MERGE (r)-[:OWNED_BY]->(u)
+                """, owner_login=owner_login,
+                     avatar_url=basic_info.get('owner', {}).get('avatar_url'),
+                     owner_type=basic_info.get('owner', {}).get('type'))
+
+        # Add languages
+        languages = self.repo_data.get("languages", {})
+        if languages:
+            for lang, bytes_count in languages.items():
+                tx.run("""
+                    MERGE (l:Language {name: $lang})
+                    MERGE (repo)-[rel:USES_LANGUAGE]->(l)
+                    SET rel.bytes = $bytes_count
+                    """, repo=repo_node, lang=lang, bytes_count=bytes_count)
+
+    def _populate_contributors(self, tx, repo_node):
+        """Populate contributors."""
+        contributors = self.repo_data.get("contributors", [])
+        if contributors:
+            for contrib in contributors:
+                tx.run("""
+                    MERGE (u:User {login: $login})
+                    ON CREATE SET u.avatarUrl = $avatar_url, u.profileUrl = $profile_url
+                    MERGE (repo)-[rel:HAS_CONTRIBUTOR]->(u)
+                    SET rel.contributions = $contributions
+                    """, repo=repo_node, login=contrib['login'],
+                         avatar_url=contrib.get('avatar_url'),
+                         profile_url=contrib.get('html_url'),
+                         contributions=contrib['contributions'])
+
+    def _populate_commits(self, tx, repo_node):
+        """Populate recent commits and link authors."""
+        commits = self.repo_data.get("recent_commits", [])
+        if commits:
+            for commit_data in commits:
+                sha = commit_data['sha']
+                commit_info = commit_data['commit']
+                author_info = commit_info.get('author', {})
+                committer_info = commit_info.get('committer', {})
+                author_login = commit_data.get('author', {}).get('login') # GitHub user if linked
+                committer_login = commit_data.get('committer', {}).get('login')
+
+                # Create commit node
+                tx.run("""
+                    MERGE (c:Commit {sha: $sha})
+                    ON CREATE SET c.message = $message, c.date = datetime($date)
+                    MERGE (repo)-[:HAS_COMMIT]->(c)
+                    """, repo=repo_node, sha=sha,
+                         message=commit_info.get('message', '')[:500], # Limit message size
+                         date=author_info.get('date')) # Use author date
+
+                # Link author (if GitHub user)
+                if author_login:
+                    tx.run("""
+                        MATCH (c:Commit {sha: $sha})
+                        MERGE (u:User {login: $login})
+                        MERGE (u)-[:AUTHORED]->(c)
+                        """, sha=sha, login=author_login)
+                # Else, could store author name/email on commit node if needed
+
+                # Link committer (if GitHub user and different from author)
+                if committer_login and committer_login != author_login:
+                     tx.run("""
+                        MATCH (c:Commit {sha: $sha})
+                        MERGE (u:User {login: $login})
+                        MERGE (u)-[:COMMITTED]->(c)
+                        """, sha=sha, login=committer_login)
+
+    # ... ( _populate_files_and_code, _populate_dependencies, populate_neo4j_graph, ...)
+    def _populate_files_and_code(self, tx, repo_node):
+        """Populate files, basic structure, and code analysis results."""
+        code_summary = self.repo_data.get("text_content", {}).get("code_summary", {})
+        text_files = self.repo_data.get("text_content", {}).get("text_files", [])
+
+        # Create file nodes first
+        for file_info in text_files:
+            path = file_info['path']
+            name = file_info['name']
+            extension = os.path.splitext(name)[1].lower()
+            is_code = extension in ['.py', '.js', '.ts', '.jsx', '.tsx'] # Add more if needed
+
+            tx.run("""
+                MERGE (f:File {path: $path})
+                ON CREATE SET f.name = $name, f.extension = $extension, f.isCode = $is_code
+                MERGE (repo)-[:CONTAINS_FILE]->(f)
+                """, repo=repo_node, path=path, name=name, extension=extension, is_code=is_code)
+
+            # If it's a code file with analysis, add details
+            if path in code_summary:
+                summary = code_summary[path]
+                metrics = summary.get('metrics', {})
+                complexity = summary.get('complexity', {})
+
+                # Add metrics
+                if metrics:
+                    tx.run("""
+                        MATCH (f:File {path: $path})
+                        SET f.linesTotal = $total, f.linesCode = $code, f.linesComment = $comment, f.linesBlank = $blank, f.commentRatio = $ratio
+                        """, path=path, total=metrics.get('total_lines'), code=metrics.get('code_lines'),
+                             comment=metrics.get('comment_lines'), blank=metrics.get('blank_lines'),
+                             ratio=metrics.get('comment_ratio'))
+
+                # Add complexity
+                if complexity:
+                    tx.run("""
+                        MATCH (f:File {path: $path})
+                        SET f.complexityCyclomatic = $cc, f.maintainabilityIndex = $mi
+                        """, path=path, cc=complexity.get('overall'), mi=complexity.get('maintainability_index'))
+
+                # Add Functions (if language supports detailed analysis)
+                for func in summary.get("detailed_functions", []):
+                     # Ensure func_name is a string
+                    func_name = str(func.get('name', 'unknown_function'))
+                    tx.run("""
+                        MATCH (f:File {path: $path})
+                        MERGE (fn:Function {name: $func_name, file: $path}) // Unique by name + file path
+                        ON CREATE SET fn.args = $args, fn.complexity = $cc, fn.docstring = $doc
+                        MERGE (f)-[:DEFINES_FUNCTION]->(fn)
+                        """, path=path, func_name=func_name,
+                             args=json.dumps(func.get('args', [])), # Store args as JSON string
+                             cc=func.get('complexity'),
+                             doc=func.get('docstring', '')[:200]) # Limit docstring
+
+                # Add Classes (if language supports detailed analysis)
+                for cls in summary.get("detailed_classes", []):
+                     # Ensure cls_name is a string
+                    cls_name = str(cls.get('name', 'unknown_class'))
+                    tx.run("""
+                        MATCH (f:File {path: $path})
+                        MERGE (cl:Class {name: $cls_name, file: $path}) // Unique by name + file path
+                        ON CREATE SET cl.methods = $methods, cl.docstring = $doc, cl.extends = $extends
+                        MERGE (f)-[:DEFINES_CLASS]->(cl)
+                        """, path=path, cls_name=cls_name,
+                             methods=json.dumps([m['name'] for m in cls.get('methods', [])]), # Store method names
+                             doc=cls.get('docstring', '')[:200],
+                             extends=cls.get('extends')) # If JS/TS analysis provides it
+
+
+    def _populate_dependencies(self, tx, repo_node):
+        """Populate internal and external code dependencies."""
+        dependencies = self.repo_data.get("text_content", {}).get("dependencies", {})
+        internal_deps = dependencies.get('internal', {})
+        external_deps = dependencies.get('external', {})
+
+        # Internal Dependencies (File -> File)
+        for source_path, target_paths in internal_deps.items():
+            for target_path in target_paths:
+                 # Ensure both files exist before creating relationship
+                tx.run("""
+                    MATCH (source:File {path: $source_path}), (target:File {path: $target_path})
+                    WHERE EXISTS(source.path) AND EXISTS(target.path) // Ensure nodes exist
+                    MERGE (source)-[:DEPENDS_ON]->(target)
+                    """, source_path=source_path, target_path=target_path)
+
+        # External Dependencies (File -> Dependency)
+        for source_path, package_names in external_deps.items():
+            for package_name in package_names:
+                 # Ensure package name is valid before creating
+                if package_name and isinstance(package_name, str):
+                    tx.run("""
+                        MATCH (source:File {path: $source_path})
+                        WHERE EXISTS(source.path) // Ensure source file exists
+                        MERGE (dep:Dependency {name: $package_name})
+                        MERGE (source)-[:IMPORTS]->(dep)
+                        """, source_path=source_path, package_name=package_name)
+
+
+    def populate_neo4j_graph(self):
+        """Populate the Neo4j graph with data from self.repo_data."""
+        if not self.neo4j_driver:
+            print("Neo4j connection not available. Skipping graph population.")
+            return
+        if not self.repo_data or not self.repo_data.get("basic_info"):
+            print("No repository data available to populate the graph.")
+            return
+
+        basic_info = self.repo_data["basic_info"]
+        full_name = basic_info['full_name']
+        print(f"Populating Neo4j graph for repository: {full_name}")
 
-    def _analyze_contributors(self) -> Dict[str, Any]:
-        """Analyze contributor statistics"""
-        contributor_data = []
+        try:
+            with self.neo4j_driver.session(database="neo4j") as session: # Ensure using correct database if needed
+                # Create/Merge Repository Node
+                repo_result = session.execute_write(
+                    lambda tx: tx.run("""
+                        MERGE (r:Repository {fullName: $full_name})
+                        ON CREATE SET
+                            r.name = $name,
+                            r.owner = $owner,
+                            r.description = $description,
+                            r.url = $url,
+                            r.createdAt = datetime($created_at),
+                            r.updatedAt = datetime($updated_at),
+                            r.stars = $stars,
+                            r.forks = $forks,
+                            r.openIssues = $open_issues,
+                            r.language = $language,
+                            r.license = $license
+                        RETURN r
+                        """, full_name=full_name,
+                                       name=basic_info['name'],
+                                       owner=basic_info['owner']['login'],
+                                       description=basic_info.get('description', ''),
+                                       url=basic_info['html_url'],
+                                       created_at=basic_info['created_at'],
+                                       updated_at=basic_info['updated_at'],
+                                       stars=basic_info['stargazers_count'],
+                                       forks=basic_info['forks_count'],
+                                       open_issues=basic_info['open_issues_count'],
+                                       language=basic_info.get('language'),
+                                       license=basic_info.get('license', {}).get('name')
+                                       ).single()[0] # Get the repo node itself
+                )
+
+                # Call helper functions within transactions for atomicity
+                session.execute_write(self._populate_basic_info, repo_result, basic_info)
+                session.execute_write(self._populate_contributors, repo_result)
+                session.execute_write(self._populate_commits, repo_result)
+                session.execute_write(self._populate_files_and_code, repo_result)
+                session.execute_write(self._populate_dependencies, repo_result)
+                # Add calls for issues, PRs etc. if needed
+
+            print(f"Successfully populated graph for {full_name}.")
+
+        except Exception as e:
+            print(f"Error populating Neo4j graph: {e}")
+
+
+    # ... ( analyze_repo, _get_graph_summary_for_llm, _node_to_string, ...)
+    def analyze_repo(self, owner, repo, display=True, save_json=False, export_text=False):
+        """Fetch, analyze, display, and optionally populate graph."""
+        self.owner = owner
+        self.repo = repo
+        self.repo_full_name = f"{owner}/{repo}"
+        print(f"\nFetching repository information for {self.repo_full_name}...")
+        # Use the github_analyzer instance associated with this GraphRepoAnalyzer
+        self.repo_data = self.github_analyzer.get_all_info(owner, repo)
+
+        if self.repo_data:
+            if display:
+                print("\nGenerating visualizations and analysis...")
+                self.github_analyzer.display_repo_info(self.repo_data)
+                self.github_analyzer.display_code_files(self.repo_data) # Show code preview
+
+            if self.neo4j_driver:
+                 populate = input("\nPopulate Neo4j graph with this data? (y/n): ").lower() == 'y'
+                 if populate:
+                     self.populate_neo4j_graph()
+
+            if save_json:
+                default_filename = f'/content/{self.repo}_info.json' if IN_COLAB else f'./{self.repo}_info.json'
+                filename = input(f"Enter filename for JSON output (default: {default_filename}): ") or default_filename
+                save_json_to_colab(self.repo_data, filename) # Use the enhanced save function
+
+            if export_text:
+                default_dir = f'/content/{self.repo}_text' if IN_COLAB else f'./{self.repo}_text'
+                output_dir = input(f"Enter output directory for text export (default: {default_dir}): ") or default_dir
+                self.github_analyzer.export_repo_text(self.repo_data, output_dir)
+        else:
+            print(f"Failed to get repository information for {self.repo_full_name}")
+
+    def _get_graph_summary_for_llm(self, max_nodes=10, max_rels=20):
+        """Fetch a small, representative sample of the graph for LLM context."""
+        if not self.neo4j_driver or not self.repo_full_name:
+            return "No graph data available."
+
+        # Get counts
+        node_counts_query = "MATCH (n) RETURN labels(n) AS label, count(*) AS count"
+        rel_counts_query = "MATCH ()-[r]->() RETURN type(r) AS type, count(*) AS count"
+        node_counts = self._run_cypher(node_counts_query)
+        rel_counts = self._run_cypher(rel_counts_query)
+
+        # Get sample nodes/rels related to the repo
+        sample_query = """
+        MATCH (repo:Repository {fullName: $repo_name})
+        // Get repo node, owner, some contributors, some files, some commits
+        OPTIONAL MATCH (repo)-[:OWNED_BY]->(owner:User)
+        OPTIONAL MATCH (repo)-[:HAS_CONTRIBUTOR]->(contrib:User)
+        WITH repo, owner, collect(contrib)[..5] AS contributors // Limit contributors
+        OPTIONAL MATCH (repo)-[:CONTAINS_FILE]->(file:File)
+        WITH repo, owner, contributors, collect(file)[..10] AS files // Limit files
+        OPTIONAL MATCH (repo)-[:HAS_COMMIT]->(commit:Commit)
+        WITH repo, owner, contributors, files, collect(commit)[..5] AS commits // Limit commits
+        // Get relationships between these sampled nodes
+        CALL apoc.path.subgraphNodes([repo, owner] + contributors + files + commits, {
+            maxLevel: 1, relationshipFilter:'>' // Only outgoing relationships from these nodes
+        }) YIELD node
+        MATCH (n)-[r]->(m)
+        WHERE n IN [repo, owner] + contributors + files + commits AND m IN [repo, owner] + contributors + files + commits
+        RETURN n AS source, type(r) AS relationship, m AS target
+        LIMIT $max_rels
+        """
+        # Note: Needs APOC installed in Neo4j for subgraphNodes.
+        # Simpler alternative without APOC: Fetch specific relationships manually.
+        # Example simple alternative:
+        # sample_query_simple = """
+        # MATCH (repo:Repository {fullName: $repo_name})
+        # OPTIONAL MATCH (repo)-[r1:OWNED_BY|:HAS_CONTRIBUTOR|:CONTAINS_FILE|:HAS_COMMIT]->(related)
+        # WITH repo, type(r1) as rel_type, related LIMIT 15
+        # RETURN repo AS source, rel_type AS relationship, related AS target
+        # """
 
         try:
-            contributors = list(self.repo.get_contributors())
-            for contributor in contributors:
-                contributor_data.append({
-                    "login": contributor.login,
-                    "contributions": contributor.contributions,
-                    "type": contributor.type,
-                })
+             # Attempt APOC query first
+            graph_sample = self._run_cypher(sample_query, {"repo_name": self.repo_full_name, "max_rels": max_rels})
         except Exception as e:
-            print(f"Error analyzing contributors: {str(e)}")
+             print(f"APOC query failed ({e}), trying simpler graph sample query.")
+             sample_query_simple = """
+             MATCH (repo:Repository {fullName: $repo_name})
+             OPTIONAL MATCH (repo)-[r1:OWNED_BY|:HAS_CONTRIBUTOR|:CONTAINS_FILE|:HAS_COMMIT|:USES_LANGUAGE]->(related)
+             WITH repo, type(r1) as rel_type, related LIMIT $max_rels
+             RETURN repo AS source, rel_type AS relationship, related AS target
+             UNION
+             MATCH (repo:Repository {fullName: $repo_name})<-[r2:AUTHORED|:COMMITTED]-(user:User)
+             WITH repo, type(r2) as rel_type, user LIMIT $max_rels
+             RETURN user AS source, rel_type AS relationship, repo AS target // Show user -> repo link
+             UNION
+             MATCH (file:File)<-[:CONTAINS_FILE]-(repo:Repository {fullName: $repo_name})
+             OPTIONAL MATCH (file)-[r3:DEFINES_FUNCTION|:DEFINES_CLASS|:DEPENDS_ON|:IMPORTS]->(related_code)
+             WITH file, type(r3) as rel_type, related_code LIMIT $max_rels
+             RETURN file AS source, rel_type AS relationship, related_code AS target
+             """
+             graph_sample = self._run_cypher(sample_query_simple, {"repo_name": self.repo_full_name, "max_rels": max_rels})
+
+
+        summary = "Graph Context Summary:\n"
+        if node_counts:
+             summary += "Node Counts: " + ", ".join([f"{c['label'][0]}: {c['count']}" for c in node_counts if c['label']]) + "\n"
+        if rel_counts:
+             summary += "Relationship Counts: " + ", ".join([f"{r['type']}: {r['count']}" for r in rel_counts if r['type']]) + "\n"
+        if graph_sample:
+             summary += f"\nSample Relationships (up to {max_rels}):\n"
+             for rel in graph_sample:
+                 # Safely extract node properties for display
+                 source_repr = self._node_to_string(rel.get('source'))
+                 target_repr = self._node_to_string(rel.get('target'))
+                 rel_type = rel.get('relationship', 'UNKNOWN_REL')
+                 if source_repr and target_repr and rel_type:
+                    summary += f"- ({source_repr})-[:{rel_type}]->({target_repr})\n"
+        else:
+             summary += "No specific graph sample retrieved.\n"
+
+        return summary.strip()
+
+    def _node_to_string(self, node):
+        """Helper to create a string representation of a Neo4j node."""
+        if not node or not hasattr(node, 'labels') or not hasattr(node, 'items'):
+            return None
+
+        label = list(node.labels)[0] if node.labels else 'Node'
+        props = dict(node.items())
+        # Choose a representative property
+        if 'fullName' in props: name = props['fullName']
+        elif 'login' in props: name = props['login']
+        elif 'path' in props: name = os.path.basename(props['path']) # Show file name
+        elif 'name' in props: name = props['name']
+        elif 'sha' in props: name = props['sha'][:7] # Short SHA
+        elif 'number' in props: name = f"#{props['number']}"
+        else: name = node.element_id # Fallback to element ID
+
+        # Limit name length
+        name_str = str(name)
+        if len(name_str) > 40:
+             name_str = name_str[:37] + "..."
+
+        return f"{label}:{name_str}"
+
+
+
+
+    def _get_pr_summary_prompt(self, pr_details, role):
+        """Generates the Gemini prompt for PR summarization based on role."""
+        # Extract key details safely
+        title = pr_details.get('title', 'N/A')
+        body = pr_details.get('body', 'No description provided.')
+        pr_number = pr_details.get('number', 'N/A')
+        repo_name = pr_details.get('repo_full_name', 'N/A')
+        author = pr_details.get('author', 'N/A')
+        state = pr_details.get('state', 'N/A')
+        merged_status = 'Merged' if pr_details.get('merged') else ('Closed' if state == 'closed' else 'Open')
+        created_at = pr_details.get('created_at', 'N/A')
+        commits_count = pr_details.get('commits_count', 'N/A')
+        changed_files = pr_details.get('changed_files_count', 'N/A')
+        additions = pr_details.get('additions', 'N/A')
+        deletions = pr_details.get('deletions', 'N/A')
+        labels = ', '.join(pr_details.get('labels', [])) or 'None'
+
+        # Truncate long body
+        max_body_len = 1500
+        truncated_body = body[:max_body_len] + ('...' if len(body) > max_body_len else '')
+
+        base_prompt = f"""
+You are an AI assistant specializing in summarizing GitHub Pull Requests.
+Analyze the following Pull Request details from repository '{repo_name}' and provide a summary tailored for a '{role}'.
+
+**Pull Request #{pr_number}: {title}**
+*   **Author:** {author}
+*   **Status:** {state.capitalize()} ({merged_status})
+*   **Created:** {created_at}
+*   **Commits:** {commits_count}
+*   **Changed Files:** {changed_files}
+*   **Code Churn:** +{additions} / -{deletions} lines
+*   **Labels:** {labels}
+*   **Description/Body:**
+{truncated_body}
+---
+"""
+        role_instructions = ""
+        # Define role-specific instructions
+        if role == 'Developer':
+            role_instructions = """
+**Summary Focus (Developer):**
+*   Summarize the core technical changes and their purpose.
+*   Identify key files, modules, or functions affected.
+*   Mention any potential technical complexities, risks, or areas needing careful code review (based *only* on the description and metadata).
+*   Note any mention of tests added or modified.
+*   Be concise and focus on technical aspects relevant for peer review or understanding the change.
+"""
+        elif role == 'Manager' or role == 'Team Lead':
+             role_instructions = """
+**Summary Focus (Manager/Team Lead):**
+*   Explain the high-level purpose and business value (what problem does this PR solve or what feature does it add?).
+*   Summarize the overall status (e.g., Ready for Review, Needs Work, Merged, Blocked?).
+*   Give a sense of the PR's size/complexity (e.g., Small/Medium/Large based on file/line changes and description).
+*   Highlight any mentioned risks, blockers, or dependencies on other work.
+*   Include the author and key dates (created, merged/closed).
+*   Focus on information needed for tracking progress and impact.
+"""
+        elif role == 'Program Manager' or role == 'Product Owner':
+            role_instructions = """
+**Summary Focus (Program/Product Manager):**
+*   Describe the user-facing impact or the feature/bug fix being addressed.
+*   Relate the PR to product goals or requirements if possible (based on title/body/labels).
+*   Note the status (especially if merged or closed).
+*   Mention associated issues or tickets if referenced in the body (though not explicitly provided here, look for patterns like '#123').
+*   Focus on 'what' and 'why' from a product perspective.
+"""
+        else: # Default/General
+            role_instructions = """
+**Summary Focus (General):**
+*   State the main goal or purpose of the PR clearly.
+*   Identify the author and the current status (Open/Closed/Merged).
+*   Provide a brief, balanced overview of the key changes made.
+*   Keep the summary accessible to a wider audience.
+"""
+
+        return base_prompt + role_instructions + "\n**Summary:**" # Ask for summary explicitly
+
+
+    def summarize_pull_request(self, pr_number, role):
+        """Fetches PR details and generates a role-based summary using Gemini."""
+        if not self.gemini_model:
+            return "Gemini model not initialized. Cannot generate summary."
+        if not self.owner or not self.repo:
+             return "Repository owner and name not set. Analyze a repository first."
+        # Use the github_analyzer instance created in __init__
+        if not self.github_analyzer:
+             return "GitHub Analyzer not initialized."
+
+
+        print(f"\nFetching details for PR #{pr_number} in {self.repo_full_name}...")
+        pr_details = self.github_analyzer.get_pull_request_details(self.owner, self.repo, pr_number)
+
+        if not pr_details:
+            return f"Could not retrieve details for PR #{pr_number}."
+
+        print(f"Generating summary for role: {role}...")
+
+        # Generate the role-specific prompt
+        prompt = self._get_pr_summary_prompt(pr_details, role)
+
+        # 4. Send to Gemini and Get Response
+        try:
+            # print("--- Sending Prompt to Gemini ---")
+            # print(prompt[:1000] + "..." if len(prompt) > 1000 else prompt) # Debug: Print truncated prompt
+            # print("-----------------------------")
 
-        return {
-            "total_contributors": len(contributor_data),
-            "contributors": contributor_data
-        }
+            response = self.gemini_model.generate_content(prompt)
 
-@retry(
-    retry=retry_if_exception_type(Exception),
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=4, max=10)
-)
-def analyze_repository(repo_url: str, progress=gr.Progress()) -> Tuple[str, str, str]:
-    """Analyze repository and generate LLM summary with rate limit handling"""
-    try:
-        # Initialize analyzer
-        progress(0, desc="Initializing repository analysis...")
-        analyzer = RepositoryAnalyzer(repo_url)
-
-        # Perform analysis
-        progress(0.3, desc="Analyzing repository structure and patterns...")
-        analysis_data = analyzer.analyze()
-
-        # Generate LLM summary
-        progress(0.7, desc="Generating analysis summary...")
-
-        system_prompt = """You are an expert code analyst with deep experience in software architecture, development practices, and team dynamics. Analyze the provided repository data and create a detailed, insightful analysis using the following markdown template:
-
-# Repository Analysis
-
-## 📊 Project Overview
-[Provide a comprehensive overview including:
-- Project purpose and scope
-- Age and maturity of the project
-- Current activity level and maintenance status
-- Key metrics (stars, forks, etc.)
-- Primary technologies and languages used in detail which language]
-
-## 🏗️ Architecture and Code Organization
-[Analyze in detail:
-- Repository structure and organization
-- Code distribution across different technologies
-- File and directory organization patterns
-- Project size and complexity metrics
-- Code modularity and component structure
-- Presence of key architectural patterns]
-
-## 💻 Development Practices & Code Quality
-[Evaluate:
-- Coding standards and consistency
-- Code complexity and maintainability metrics
-- Documentation practices
-- Testing approach and coverage (if visible)
-- Error handling and logging practices
-- Use of design patterns and best practices]
-
-## 📈 Development Workflow & History
-[Analyze:
-- Commit patterns and frequency
-- Release cycles and versioning
-- Branch management strategy
-- Code review practices
-- Continuous integration/deployment indicators
-- Peak development periods and cycles]
-
-## 👥 Team Dynamics & Collaboration
-[Examine:
-- Team size and composition
-- Contribution patterns
-- Core maintainer identification
-- Community engagement level
-- Communication patterns
-- Collaboration efficiency]
-
-## 🔧 Technical Depth & Innovation
-[Assess:
-- Technical sophistication level
-- Innovative approaches or solutions
-- Complex problem-solving examples
-- Performance optimization efforts
-- Security considerations
-- Scalability approach]
-
-## 🚀 Project Health & Sustainability
-[Evaluate:
-- Project momentum and growth trends
-- Maintenance patterns
-- Community health indicators
-- Documentation completeness
-- Onboarding friendliness
-- Long-term viability indicators]
-
-## 💡 Key Insights & Recommendations
-[Provide:
-- 3-5 key strengths identified
-- 3-5 potential improvement areas
-- Notable patterns or practices
-- Unique characteristics
-- Strategic recommendations]
-
-Please provide detailed analysis for each section while maintaining the formatting and emojis. Support insights with specific metrics and examples from the repository data where possible."""
-
-        chat = model.start_chat(history=[])
-        response = chat.send_message(f"{system_prompt}\n\nRepository Analysis Data:\n{json.dumps(analysis_data, indent=2)}")
-
-        # Save analysis data
-        progress(0.9, desc="Saving analysis results...")
-        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json') as f:
-            json.dump(analysis_data, f, indent=2)
-            analysis_file = f.name
-
-        progress(1.0, desc="Analysis complete!")
-        return response.text, analysis_file, "✅ Analysis completed successfully!"
-
-    except Exception as e:
-        error_message = f"❌ Error analyzing repository: {str(e)}"
-        return "", "", error_message
-
-def create_chat_session() -> Any:
-    """Create a new chat session for follow-up questions"""
-    return genai.GenerativeModel(
-        model_name="gemini-pro",
-        generation_config={
-            'temperature': 0.7,
-            'top_p': 0.8,
-            'top_k': 40,
-            'max_output_tokens': 2048,
-        }
-    )
-
-@retry(
-    retry=retry_if_exception_type(Exception),
-    stop=stop_after_attempt(3),
-    wait=wait_exponential(multiplier=1, min=4, max=10)
-)
-def ask_question(question: str, analysis_file: str, chat_history: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
-    """Process a follow-up question about the analysis"""
-    if not analysis_file:
-        return chat_history + [(question, "Please analyze a repository first before asking questions.")]
+            print("\n--- Gemini PR Summary ---")
+            summary_text = response.text
+            display(Markdown(summary_text))
+            print("------------------------")
+            return summary_text
 
-    try:
-        # Load analysis data
-        with open(analysis_file, 'r') as f:
-            analysis_data = json.load(f)
+        except Exception as e:
+            print(f"Error communicating with Gemini for PR summary: {e}")
+            return f"Error asking Gemini: {e}"
+    # ... ( _get_repo_summary_for_llm, ask_gemini_about_repo )
+    def _get_repo_summary_for_llm(self):
+        """Create a concise text summary of the repo_data for the LLM prompt."""
+        if not self.repo_data or not self.repo_data.get("basic_info"):
+            return "No repository data available."
 
-        # Initialize chat model
-        model = create_chat_session()
+        basic = self.repo_data["basic_info"]
+        summary = f"Repository Summary: {basic['full_name']}\n"
+        summary += f"Description: {basic.get('description', 'N/A')}\n"
+        summary += f"Stars: {basic.get('stargazers_count', 0)}, Forks: {basic.get('forks_count', 0)}, Open Issues: {basic.get('open_issues_count', 0)}\n"
+        summary += f"Main Language: {basic.get('language', 'N/A')}\n"
+        summary += f"Last Updated: {basic.get('updated_at', 'N/A')}\n"
 
-        # Build context from chat history and current question
-        context = "You are an expert code analyst helping users understand repository analysis results.\n\n"
-        context += f"Repository Analysis Data:\n{json.dumps(analysis_data, indent=2)}\n\n"
+        if self.repo_data.get("languages"):
+            langs = list(self.repo_data["languages"].keys())
+            summary += f"Languages Used: {', '.join(langs[:5])}{'...' if len(langs) > 5 else ''}\n"
 
-        # Add chat history context
-        if chat_history:
-            context += "Previous conversation:\n"
-            for user_msg, assistant_msg in chat_history:
-                context += f"User: {user_msg}\nAssistant: {assistant_msg}\n"
+        if self.repo_data.get("contributors"):
+            contribs = [c['login'] for c in self.repo_data["contributors"][:5]]
+            summary += f"Top Contributors: {', '.join(contribs)}{'...' if len(self.repo_data['contributors']) > 5 else ''}\n"
 
-        # Add current question
-        prompt = context + f"\nUser: {question}\nPlease provide your analysis:"
+        if self.repo_data.get("text_content", {}).get("aggregate_metrics"):
+            metrics = self.repo_data["text_content"]["aggregate_metrics"]
+            summary += f"Code Metrics (approx): {metrics.get('total_code_lines', 0)} LoC, Comment Ratio: {metrics.get('average_comment_ratio', 0):.2f}\n"
 
-        # Get response
-        response = model.generate_content(prompt)
+        # Add complexity summary if available
+        complexity_data = self.repo_data.get("text_content", {}).get("complexity_metrics",{}).get("cyclomatic_complexity", [])
+        if complexity_data:
+            cc_values = [c[1] for c in complexity_data if isinstance(c[1], (int, float))] # Extract valid numbers
+            if cc_values:
+                 summary += f"Avg Cyclomatic Complexity: {np.mean(cc_values):.2f}\n"
 
-        # Return in the correct tuple format for Gradio chatbot
-        return chat_history + [(question, response.text)]
+        # Add dependency summary if available
+        deps = self.repo_data.get("text_content", {}).get("dependencies", {}).get("external", {})
+        if deps:
+             ext_counts = Counter()
+             for dep_list in deps.values():
+                 ext_counts.update(dep for dep in dep_list if isinstance(dep, str)) # Count valid string deps
+             top_deps = ext_counts.most_common(5)
+             if top_deps:
+                 summary += f"Top External Dependencies: {', '.join([d[0] for d in top_deps])}\n"
 
-    except Exception as e:
-        error_message = f"Error processing question: {str(e)}"
-        return chat_history + [(question, error_message)]
 
+        return summary.strip()
 
+    def ask_gemini_about_repo(self, question):
+        """Ask Gemini a question about the analyzed repository, using graph context."""
+        if not self.gemini_model:
+            return "Gemini model not initialized. Please provide GOOGLE_API_KEY."
+        if not self.repo_data:
+            return "No repository has been analyzed yet. Run analyze_repo() first."
 
+        print("\nAsking Gemini...")
 
-# Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("""
-    # 🔍 GitHub Repository Analyzer
-
-    Analyze any public GitHub repository using AI. The tool will:
-    1. 📊 Analyze repository structure and patterns
-    2. 💡 Generate insights about development practices
-    3. 💭 Allow you to ask follow-up questions about the analysis
-
-    Enter a GitHub repository URL (e.g., `https://github.com/owner/repo`)
-    """)
-
-    with gr.Row():
-        repo_url = gr.Textbox(
-            label="GitHub Repository URL",
-            placeholder="https://github.com/owner/repo",
-            scale=4
-        )
-        analyze_btn = gr.Button("🔍 Analyze", variant="primary", scale=1)
+        # 1. Get Base Summary Context (from fetched GitHub data)
+        repo_summary = self._get_repo_summary_for_llm()
 
-    # Add status message
-    status_msg = gr.Markdown("", elem_id="status_message")
+        # 2. Get Graph Context (GraphRAG - Retrieval Step)
+        #    (Simple version: get generic graph summary. Advanced: tailor query to question)
+        graph_context = self._get_graph_summary_for_llm() # Use the helper
 
-    with gr.Row():
-        # Use Markdown instead of Textbox for better formatting
-        summary = gr.Markdown(
-            label="Analysis Summary",
-        )
+        # 3. Construct the Prompt
+        prompt = f"""You are an expert software engineering assistant analyzing the GitHub repository '{self.repo_full_name}'.
+You have access to the following information:
 
-    with gr.Row():
-        chatbot = gr.Chatbot(
-            label="Ask Questions",
-            height=400,
-            show_label=True
-        )
+**Repository Summary (from GitHub API):**
+{repo_summary}
+
+**Knowledge Graph Context (Sample from Neo4j):**
+{graph_context}
+
+---
+
+Based *only* on the information provided above, please answer the following question:
 
-    with gr.Row():
-        question = gr.Textbox(
-            label="Your Question",
-            placeholder="Ask about the analysis...",
-            scale=4
+**Question:** {question}
+
+---
+
+Provide a concise and informative answer, referencing the data sources (summary or graph) where possible. If the information isn't available in the provided context, state that explicitly.
+"""
+
+        # 4. Send to Gemini and Get Response
+        try:
+            print("--- Sending Prompt to Gemini ---")
+            print(prompt[:1000] + "..." if len(prompt) > 1000 else prompt) # Print truncated prompt for review
+            print("-----------------------------")
+
+            response = self.gemini_model.generate_content(prompt)
+
+            print("\n--- Gemini's Response ---")
+            # Display response using Markdown for better formatting
+            display(Markdown(response.text))
+            print("------------------------")
+            return response.text
+
+        except Exception as e:
+            print(f"Error communicating with Gemini: {e}")
+            return f"Error asking Gemini: {e}"
+
+    def __init__(self, github_token=None, neo4j_uri=None, neo4j_user=None, neo4j_password=None, gemini_api_key=None):
+        """Initialize with credentials."""
+        load_dotenv() # Load .env file if it exists
+
+        self.github_token = github_token or os.getenv("GITHUB_TOKEN")
+        self.neo4j_uri = neo4j_uri or os.getenv("NEO4J_URI")
+        self.neo4j_user = neo4j_user or os.getenv("NEO4J_USERNAME")
+        self.neo4j_password = neo4j_password or os.getenv("NEO4J_PASSWORD")
+        self.gemini_api_key = gemini_api_key or os.getenv("GOOGLE_API_KEY")
+
+        self.neo4j_driver = None
+        self.gemini_model = None
+        # Initialize github_analyzer using the potentially updated GitHubRepoInfo
+        self.github_analyzer = GitHubRepoInfo(token=self.github_token)
+
+        if not all([self.neo4j_uri, self.neo4j_user, self.neo4j_password]):
+            print("Warning: Neo4j credentials not fully provided. Graph features will be disabled.")
+        else:
+            try:
+                self.neo4j_driver = GraphDatabase.driver(self.neo4j_uri, auth=basic_auth(self.neo4j_user, self.neo4j_password))
+                self.neo4j_driver.verify_connectivity()
+                print("Successfully connected to Neo4j.")
+                self._create_neo4j_constraints()
+            except Exception as e:
+                print(f"Error connecting to Neo4j: {e}")
+                print("Graph features will be disabled.")
+                self.neo4j_driver = None
+
+        if not self.gemini_api_key:
+            print("Warning: Google API Key not provided. Gemini features will be disabled.")
+        else:
+            try:
+                genai.configure(api_key=self.gemini_api_key)
+                self.gemini_model = genai.GenerativeModel('gemini-2.0-flash-thinking-exp-01-21')
+                print("Gemini 1.5 Pro model initialized.")
+            except Exception as e:
+                print(f"Error initializing Gemini: {e}")
+                self.gemini_model = None
+
+        self.repo_data = None
+        self.repo_full_name = None # Store repo name for context
+        self.owner = None # Store owner
+        self.repo = None # Store repo name
+
+
+    def analyze_repo(self, owner, repo, display=True, save_json=False, export_text=False):
+        """Fetch, analyze, display, and optionally populate graph."""
+        self.owner = owner
+        self.repo = repo
+        self.repo_full_name = f"{owner}/{repo}"
+        print(f"\nFetching repository information for {self.repo_full_name}...")
+        # Use the github_analyzer instance associated with this GraphRepoAnalyzer
+        self.repo_data = self.github_analyzer.get_all_info(owner, repo)
+
+        if self.repo_data:
+            if display:
+                print("\nGenerating visualizations and analysis...")
+                self.github_analyzer.display_repo_info(self.repo_data)
+                self.github_analyzer.display_code_files(self.repo_data) # Show code preview
+
+            if self.neo4j_driver:
+                 populate = input("\nPopulate Neo4j graph with this data? (y/n): ").lower() == 'y'
+                 if populate:
+                     self.populate_neo4j_graph()
+
+            if save_json:
+                default_filename = f'/content/{self.repo}_info.json' if IN_COLAB else f'./{self.repo}_info.json'
+                filename = input(f"Enter filename for JSON output (default: {default_filename}): ") or default_filename
+                save_json_to_colab(self.repo_data, filename) # Use the enhanced save function
+
+            if export_text:
+                default_dir = f'/content/{self.repo}_text' if IN_COLAB else f'./{self.repo}_text'
+                output_dir = input(f"Enter output directory for text export (default: {default_dir}): ") or default_dir
+                self.github_analyzer.export_repo_text(self.repo_data, output_dir)
+        else:
+            print(f"Failed to get repository information for {self.repo_full_name}")
+
+
+    def _get_pr_summary_prompt(self, pr_details, role):
+        """Generates the Gemini prompt for PR summarization based on role."""
+        # Extract key details safely
+        title = pr_details.get('title', 'N/A')
+        body = pr_details.get('body', 'No description provided.')
+        pr_number = pr_details.get('number', 'N/A')
+        repo_name = pr_details.get('repo_full_name', 'N/A')
+        author = pr_details.get('author', 'N/A')
+        state = pr_details.get('state', 'N/A')
+        merged_status = 'Merged' if pr_details.get('merged') else ('Closed' if state == 'closed' else 'Open')
+        created_at = pr_details.get('created_at', 'N/A')
+        commits_count = pr_details.get('commits_count', 'N/A')
+        changed_files = pr_details.get('changed_files_count', 'N/A')
+        additions = pr_details.get('additions', 'N/A')
+        deletions = pr_details.get('deletions', 'N/A')
+        labels = ', '.join(pr_details.get('labels', [])) or 'None'
+
+        # Truncate long body
+        max_body_len = 1500
+        truncated_body = body[:max_body_len] + ('...' if len(body) > max_body_len else '')
+
+        base_prompt = f"""
+You are an AI assistant specializing in summarizing GitHub Pull Requests.
+Analyze the following Pull Request details from repository '{repo_name}' and provide a summary tailored for a '{role}'.
+
+**Pull Request #{pr_number}: {title}**
+*   **Author:** {author}
+*   **Status:** {state.capitalize()} ({merged_status})
+*   **Created:** {created_at}
+*   **Commits:** {commits_count}
+*   **Changed Files:** {changed_files}
+*   **Code Churn:** +{additions} / -{deletions} lines
+*   **Labels:** {labels}
+*   **Description/Body:**
+{truncated_body}
+---
+"""
+        role_instructions = ""
+        # Define role-specific instructions
+        if role == 'Developer':
+            role_instructions = """
+**Summary Focus (Developer):**
+*   Summarize the core technical changes and their purpose.
+*   Identify key files, modules, or functions affected.
+*   Mention any potential technical complexities, risks, or areas needing careful code review (based *only* on the description and metadata).
+*   Note any mention of tests added or modified.
+*   Be concise and focus on technical aspects relevant for peer review or understanding the change.
+"""
+        elif role == 'Manager' or role == 'Team Lead':
+             role_instructions = """
+**Summary Focus (Manager/Team Lead):**
+*   Explain the high-level purpose and business value (what problem does this PR solve or what feature does it add?).
+*   Summarize the overall status (e.g., Ready for Review, Needs Work, Merged, Blocked?).
+*   Give a sense of the PR's size/complexity (e.g., Small/Medium/Large based on file/line changes and description).
+*   Highlight any mentioned risks, blockers, or dependencies on other work.
+*   Include the author and key dates (created, merged/closed).
+*   Focus on information needed for tracking progress and impact.
+"""
+        elif role == 'Program Manager' or role == 'Product Owner':
+            role_instructions = """
+**Summary Focus (Program/Product Manager):**
+*   Describe the user-facing impact or the feature/bug fix being addressed.
+*   Relate the PR to product goals or requirements if possible (based on title/body/labels).
+*   Note the status (especially if merged or closed).
+*   Mention associated issues or tickets if referenced in the body (though not explicitly provided here, look for patterns like '#123').
+*   Focus on 'what' and 'why' from a product perspective.
+"""
+        else: # Default/General
+            role_instructions = """
+**Summary Focus (General):**
+*   State the main goal or purpose of the PR clearly.
+*   Identify the author and the current status (Open/Closed/Merged).
+*   Provide a brief, balanced overview of the key changes made.
+*   Keep the summary accessible to a wider audience.
+"""
+
+        return base_prompt + role_instructions + "\n**Summary:**" # Ask for summary explicitly
+
+
+    def summarize_pull_request(self, pr_number, role):
+        """Fetches PR details and generates a role-based summary using Gemini."""
+        if not self.gemini_model:
+            return "Gemini model not initialized. Cannot generate summary."
+        if not self.owner or not self.repo:
+             return "Repository owner and name not set. Analyze a repository first."
+        # Use the github_analyzer instance created in __init__
+        if not self.github_analyzer:
+             return "GitHub Analyzer not initialized."
+
+
+        print(f"\nFetching details for PR #{pr_number} in {self.repo_full_name}...")
+        pr_details = self.github_analyzer.get_pull_request_details(self.owner, self.repo, pr_number)
+
+        if not pr_details:
+            return f"Could not retrieve details for PR #{pr_number}."
+
+        print(f"Generating summary for role: {role}...")
+
+        # Generate the role-specific prompt
+        prompt = self._get_pr_summary_prompt(pr_details, role)
+
+        # 4. Send to Gemini and Get Response
+        try:
+            # print("--- Sending Prompt to Gemini ---")
+            # print(prompt[:1000] + "..." if len(prompt) > 1000 else prompt) # Debug: Print truncated prompt
+            # print("-----------------------------")
+
+            response = self.gemini_model.generate_content(prompt)
+
+            print("\n--- Gemini PR Summary ---")
+            summary_text = response.text
+            display(Markdown(summary_text))
+            print("------------------------")
+            return summary_text
+
+        except Exception as e:
+            print(f"Error communicating with Gemini for PR summary: {e}")
+            return f"Error asking Gemini: {e}"
+
+    def create_vizro_dashboard(self, output_dir='./vizro_dashboard'):
+        """Create a Vizro dashboard from repository data."""
+        if not self.repo_data:
+            print("No repository data available. Run analyze_repo() first.")
+            return None
+            
+        # Create output directory if it doesn't exist
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+            
+        # Extract repository data
+        repo_name = self.repo_data["basic_info"]["full_name"]
+        basic_info = self.repo_data["basic_info"]
+        
+        # Create dashboard pages
+        pages = []
+        
+        # 1. Overview Page
+        overview_components = []
+        
+        # Basic repository info as a card
+        repo_info_md = f"""
+        # {basic_info['full_name']}
+        
+        **Description:** {basic_info.get('description', 'No description')}
+        
+        **Stars:** {basic_info['stargazers_count']} | 
+        **Forks:** {basic_info['forks_count']} | 
+        **Open Issues:** {basic_info['open_issues_count']}
+        
+        **Created:** {basic_info['created_at']} | 
+        **Last Updated:** {basic_info['updated_at']}
+        
+        **Default Branch:** {basic_info['default_branch']}
+        
+        **License:** {basic_info['license']['name'] if basic_info.get('license') else 'Not specified'}
+        """
+        
+        overview_components.append(vzm.Card(text=repo_info_md))
+        
+        # Languages pie chart
+        if self.repo_data.get("languages"):
+            langs_data = []
+            total = sum(self.repo_data["languages"].values())
+            for lang, bytes_count in self.repo_data["languages"].items():
+                percentage = (bytes_count / total) * 100
+                langs_data.append({
+                    "Language": lang,
+                    "Bytes": bytes_count,
+                    "Percentage": percentage
+                })
+                
+            langs_df = pd.DataFrame(langs_data)
+            
+            lang_pie = vzm.Graph(
+                figure=px.pie(
+                    langs_df, 
+                    values="Percentage", 
+                    names="Language", 
+                    title="Language Distribution"
+                )
+            )
+            
+            overview_components.append(vzm.Card(graph=lang_pie))
+        
+        # Contributors bar chart
+        if self.repo_data.get("contributors"):
+            contrib_data = []
+            for contributor in self.repo_data["contributors"][:15]:
+                contrib_data.append({
+                    "Username": contributor['login'],
+                    "Contributions": contributor['contributions']
+                })
+                
+            contrib_df = pd.DataFrame(contrib_data)
+            
+            contrib_bar = vzm.Graph(
+                figure=px.bar(
+                    contrib_df, 
+                    x="Username", 
+                    y="Contributions", 
+                    title="Top Contributors"
+                )
+            )
+            
+            overview_components.append(vzm.Card(graph=contrib_bar))
+        
+        # Add overview page
+        pages.append(
+            vzm.Page(
+                title="Overview",
+                components=overview_components
+            )
         )
-        ask_btn = gr.Button("💭 Ask", variant="primary", scale=1)
-        clear_btn = gr.Button("🗑️ Clear Chat", variant="secondary", scale=1)
-
-    # Hidden state for analysis file
-    analysis_file = gr.State("")
-
-    def clear_outputs():
-        return "", [], "", ""
-
-    # Set up event handlers
-    analyze_btn.click(
-        fn=lambda: "⏳ Analysis in progress...",
-        inputs=None,
-        outputs=status_msg,
-        queue=False
-    ).then(
-        analyze_repository,
-        inputs=[repo_url],
-        outputs=[summary, analysis_file, status_msg],
-    )
-
-    ask_btn.click(
-        ask_question,
-        inputs=[question, analysis_file, chatbot],
-        outputs=[chatbot],
-    ).then(
-        lambda: "",  # Clear the question input
-        None,
-        question,
-        queue=False
-    )
-
-    clear_btn.click(
-        clear_outputs,
-        inputs=None,
-        outputs=[summary, chatbot, question, status_msg],
-        queue=False
-    )
-
-# Launch the app
-if __name__ == "__main__":
-    app.launch(
-        share=True,
-        debug=True
-    )
+        
+        # 2. Activity Page
+        activity_components = []
+        
+        # Commit activity over time
+        weekly_commits = self.repo_data.get("temporal_analysis", {}).get("weekly_commits", [])
+        if weekly_commits:
+            commits_df = pd.DataFrame([
+                {"Date": week['date'], "Commits": week['total']} 
+                for week in weekly_commits
+            ])
+            
+            commits_line = vzm.Graph(
+                figure=px.line(
+                    commits_df, 
+                    x="Date", 
+                    y="Commits", 
+                    title="Weekly Commit Activity"
+                )
+            )
+            
+            activity_components.append(vzm.Card(graph=commits_line))
+        
+        # Code changes over time
+        weekly_code_changes = self.repo_data.get("temporal_analysis", {}).get("weekly_code_changes", [])
+        if weekly_code_changes:
+            changes_data = []
+            for week in weekly_code_changes:
+                changes_data.append({
+                    "Date": week['date'],
+                    "Additions": week['additions'],
+                    "Deletions": -abs(week['deletions'])  # Make negative for visualization
+                })
+                
+            changes_df = pd.DataFrame(changes_data)
+            
+            # Create a stacked bar chart
+            changes_fig = go.Figure()
+            changes_fig.add_trace(go.Bar(
+                x=changes_df["Date"],
+                y=changes_df["Additions"],
+                name="Additions",
+                marker_color="green"
+            ))
+            changes_fig.add_trace(go.Bar(
+                x=changes_df["Date"],
+                y=changes_df["Deletions"],
+                name="Deletions",
+                marker_color="red"
+            ))
+            changes_fig.update_layout(
+                title="Weekly Code Changes",
+                barmode="relative"
+            )
+            
+            changes_chart = vzm.Graph(figure=changes_fig)
+            activity_components.append(vzm.Card(graph=changes_chart))
+        
+        # Issue resolution times
+        issue_timeline = self.repo_data.get("temporal_analysis", {}).get("issue_timeline", {})
+        if issue_timeline and issue_timeline.get('resolution_times'):
+            resolution_times = issue_timeline['resolution_times']
+            
+            # Convert to hours for better visualization (cap at one week)
+            rt_hours = [min(rt, 168) for rt in resolution_times if rt is not None]
+            
+            # Create histogram
+            issue_resolution_fig = px.histogram(
+                x=rt_hours,
+                title="Issue Resolution Times (Capped at 1 Week)",
+                labels={"x": "Hours to Resolution", "y": "Number of Issues"}
+            )
+            
+            # Add mean and median lines
+            if rt_hours:
+                mean_rt = np.mean(rt_hours)
+                median_rt = np.median(rt_hours)
+                
+                issue_resolution_fig.add_vline(
+                    x=mean_rt,
+                    line_dash="dash",
+                    line_color="red",
+                    annotation_text=f"Mean: {mean_rt:.2f} hours"
+                )
+                issue_resolution_fig.add_vline(
+                    x=median_rt,
+                    line_dash="dash",
+                    line_color="green",
+                    annotation_text=f"Median: {median_rt:.2f} hours"
+                )
+            
+            resolution_hist = vzm.Graph(figure=issue_resolution_fig)
+            activity_components.append(vzm.Card(graph=resolution_hist))
+        
+        # Add activity page
+        pages.append(
+            vzm.Page(
+                title="Activity",
+                components=activity_components
+            )
+        )
+        
+        # 3. Code Quality Page
+        code_components = []
+        
+        # Code complexity metrics
+        complexity_metrics = self.repo_data.get("text_content", {}).get("complexity_metrics", {})
+        cyclomatic_complexity = complexity_metrics.get("cyclomatic_complexity", [])
+        
+        if cyclomatic_complexity:
+            # Prepare data for top complex files
+            complexity_data = []
+            for path, cc in cyclomatic_complexity:
+                # Ensure cc is numeric
+                if isinstance(cc, (int, float)):
+                    complexity_data.append({
+                        "File": os.path.basename(path),
+                        "Path": path,
+                        "Complexity": cc
+                    })
+                    
+            if complexity_data:
+                # Sort by complexity
+                complexity_data.sort(key=lambda x: x["Complexity"], reverse=True)
+                # Take top 10
+                top_complex_files = complexity_data[:10]
+                
+                complex_df = pd.DataFrame(top_complex_files)
+                
+                complex_bar = vzm.Graph(
+                    figure=px.bar(
+                        complex_df,
+                        x="File",
+                        y="Complexity",
+                        title="Most Complex Files",
+                        hover_data=["Path"]
+                    )
+                )
+                
+                code_components.append(vzm.Card(graph=complex_bar))
+                
+                # Complexity histogram
+                cc_values = [d["Complexity"] for d in complexity_data]
+                
+                cc_hist = vzm.Graph(
+                    figure=px.histogram(
+                        x=cc_values,
+                        title="Cyclomatic Complexity Distribution",
+                        labels={"x": "Complexity", "y": "Number of Files"}
+                    )
+                )
+                
+                code_components.append(vzm.Card(graph=cc_hist))
+        
+        # Comment ratio by file
+        comment_ratios = complexity_metrics.get("comment_ratios", [])
+        if comment_ratios:
+            comment_data = []
+            for path, ratio in comment_ratios:
+                comment_data.append({
+                    "File": os.path.basename(path),
+                    "Path": path,
+                    "Comment Ratio": ratio
+                })
+                
+            # Sort by ratio
+            comment_data.sort(key=lambda x: x["Comment Ratio"], reverse=True)
+            # Take top 10
+            top_commented_files = comment_data[:10]
+            
+            comment_df = pd.DataFrame(top_commented_files)
+            
+            comment_bar = vzm.Graph(
+                figure=px.bar(
+                    comment_df,
+                    x="File",
+                    y="Comment Ratio",
+                    title="Most Commented Files",
+                    hover_data=["Path"]
+                )
+            )
+            
+            code_components.append(vzm.Card(graph=comment_bar))
+        
+        # Add code quality page
+        pages.append(
+            vzm.Page(
+                title="Code Quality",
+                components=code_components
+            )
+        )
+        
+        # 4. Dependencies Page
+        dependencies = self.repo_data.get("text_content", {}).get("dependencies", {})
+        if dependencies:
+            dependencies_components = []
+            
+            # External dependencies
+            external_deps = dependencies.get("external", {})
+            if external_deps:
+                # Count packages
+                ext_counts = Counter()
+                for file_deps in external_deps.values():
+                    ext_counts.update(dep for dep in file_deps if isinstance(dep, str))
+                
+                # Get top dependencies
+                top_deps = ext_counts.most_common(10)
+                
+                deps_data = []
+                for pkg, count in top_deps:
+                    deps_data.append({
+                        "Package": pkg,
+                        "Count": count
+                    })
+                    
+                deps_df = pd.DataFrame(deps_data)
+                
+                deps_bar = vzm.Graph(
+                    figure=px.bar(
+                        deps_df,
+                        x="Package",
+                        y="Count",
+                        title="Most Used External Dependencies"
+                    )
+                )
+                
+                dependencies_components.append(vzm.Card(graph=deps_bar))
+            
+            # Internal dependencies
+            internal_deps = dependencies.get("internal", {})
+            if internal_deps and len(internal_deps) <= 50:  # Only for smaller graphs
+                try:
+                    # Create NetworkX graph
+                    G = nx.DiGraph()
+                    
+                    # Add nodes and edges
+                    for source, targets in internal_deps.items():
+                        source_name = os.path.basename(source)
+                        G.add_node(source, name=source_name)
+                        
+                        for target in targets:
+                            target_name = os.path.basename(target)
+                            G.add_node(target, name=target_name)
+                            G.add_edge(source, target)
+                    
+                    # Get position layout
+                    pos = nx.spring_layout(G, seed=42)
+                    
+                    # Create graph visualization
+                    edge_x = []
+                    edge_y = []
+                    for edge in G.edges():
+                        x0, y0 = pos[edge[0]]
+                        x1, y1 = pos[edge[1]]
+                        edge_x.extend([x0, x1, None])
+                        edge_y.extend([y0, y1, None])
+                        
+                    edge_trace = go.Scatter(
+                        x=edge_x, y=edge_y,
+                        line=dict(width=0.5, color='#888'),
+                        hoverinfo='none',
+                        mode='lines')
+                    
+                    node_x = []
+                    node_y = []
+                    node_text = []
+                    for node in G.nodes():
+                        x, y = pos[node]
+                        node_x.append(x)
+                        node_y.append(y)
+                        node_text.append(G.nodes[node].get('name', node))
+                        
+                    node_trace = go.Scatter(
+                        x=node_x, y=node_y,
+                        mode='markers+text',
+                        hoverinfo='text',
+                        text=node_text,
+                        textposition="top center",
+                        marker=dict(
+                            showscale=True,
+                            colorscale='YlGnBu',
+                            size=10,
+                            colorbar=dict(
+                                thickness=15,
+                                title='Node Connections',
+                                xanchor='left',
+                                titleside='right'
+                            )
+                        ),
+                        textfont=dict(
+                            family="Arial",
+                            size=8,
+                            color="black"
+                        ),
+                    )
+                    
+                    # Color by node degree
+                    node_adjacencies = []
+                    for node in G.nodes():
+                        node_adjacencies.append(len(list(G.predecessors(node))) + len(list(G.successors(node))))
+                        
+                    node_trace.marker.color = node_adjacencies
+                    
+                    # Create figure
+                    fig = go.Figure(data=[edge_trace, node_trace],
+                                    layout=go.Layout(
+                                        title='File Dependency Network',
+                                        showlegend=False,
+                                        hovermode='closest',
+                                        margin=dict(b=20, l=5, r=5, t=40),
+                                        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                                        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))
+                                    )
+                    
+                    dependencies_components.append(vzm.Card(graph=vzm.Graph(figure=fig)))
+                    
+                except Exception as e:
+                    print(f"Error generating dependency network: {e}")
+            
+            # Add dependencies page if we have components
+            if dependencies_components:
+                pages.append(
+                    vzm.Page(
+                        title="Dependencies",
+                        components=dependencies_components
+                    )
+                )
+        
+        # Create the dashboard
+        dashboard = vzm.Dashboard(
+            title=f"GitHub Repository Analysis: {repo_name}",
+            pages=pages
+        )
+        
+        # Export dashboard
+        dashboard_path = os.path.join(output_dir, "dashboard.html")
+        dashboard.save(dashboard_path)
+        print(f"Vizro dashboard saved to {dashboard_path}")
+        
+        return dashboard
 
 
+# Create Gradio interface
+def create_gradio_interface():
+    """Create a Gradio interface for the GitHub repository analyzer."""
+    
+    def analyze_repository(owner, repo, github_token=None, neo4j_uri=None, neo4j_user=None, neo4j_password=None, gemini_api_key=None):
+        """Function to analyze a repository and return a Vizro dashboard."""
+        try:
+            analyzer = GraphRepoAnalyzer(
+                github_token=github_token if github_token else None,
+                neo4j_uri=neo4j_uri if neo4j_uri else None,
+                neo4j_user=neo4j_user if neo4j_user else None,
+                neo4j_password=neo4j_password if neo4j_password else None,
+                gemini_api_key=gemini_api_key if gemini_api_key else None
+            )
+            
+            # Analyze repository
+            analyzer.analyze_repo(owner, repo, display=False, save_json=False, export_text=False)
+            
+            if not analyzer.repo_data:
+                return None, f"Failed to analyze repository: {owner}/{repo}. Check the repository name and your GitHub token."
+            
+            # Create Vizro dashboard
+            dashboard = analyzer.create_vizro_dashboard(output_dir='./vizro_dashboard')
+            
+            # Path to dashboard HTML
+            dashboard_path = os.path.join('./vizro_dashboard', 'dashboard.html')
+            
+            # Generate a simple report
+            basic_info = analyzer.repo_data["basic_info"]
+            report = f"""
+### Repository Analysis: {basic_info['full_name']}
+
+**Description:** {basic_info.get('description', 'No description')}
+
+**Statistics:**
+- Stars: {basic_info['stargazers_count']}
+- Forks: {basic_info['forks_count']}
+- Open Issues: {basic_info['open_issues_count']}
+
+**Interactive Dashboard:**
+The full interactive Vizro dashboard has been created at: `{dashboard_path}`
+
+**Language Summary:**
+"""
+            
+            # Add language info
+            if analyzer.repo_data.get("languages"):
+                langs = analyzer.repo_data["languages"]
+                total = sum(langs.values())
+                for lang, bytes_count in sorted(langs.items(), key=lambda x: x[1], reverse=True):
+                    percentage = (bytes_count / total) * 100
+                    report += f"- {lang}: {percentage:.1f}%\n"
+            
+            # Add code metrics if available
+            if analyzer.repo_data.get("text_content", {}).get("aggregate_metrics"):
+                metrics = analyzer.repo_data["text_content"]["aggregate_metrics"]
+                report += f"""
+**Code Metrics:**
+- Total Files Analyzed: {metrics.get('total_files', 'N/A')}
+- Total Code Lines: {metrics.get('total_code_lines', 'N/A')}
+- Comment Ratio: {metrics.get('average_comment_ratio', 'N/A'):.2f}
+"""
+            
+            return dashboard_path, report
+            
+        except Exception as e:
+            return None, f"Error analyzing repository: {str(e)}"
+    
+    def summarize_pr(owner, repo, pr_number, role, github_token=None, gemini_api_key=None):
+        """Function to summarize a PR for Gradio."""
+        try:
+            analyzer = GraphRepoAnalyzer(
+                github_token=github_token if github_token else None,
+                gemini_api_key=gemini_api_key if gemini_api_key else None
+            )
+            
+            # Set repo info
+            analyzer.owner = owner
+            analyzer.repo = repo
+            analyzer.repo_full_name = f"{owner}/{repo}"
+            
+            # Summarize the PR
+            summary = analyzer.summarize_pull_request(int(pr_number), role)
+            
+            return summary
+            
+        except Exception as e:
+            return f"Error summarizing PR: {str(e)}"
+    
+    # UI Components
+    with gr.Blocks(title="GitHub Repository Analyzer") as app:
+        gr.Markdown("# GitHub Repository Analyzer with Vizro and Gemini Integration")
+        gr.Markdown("Analyze GitHub repositories, create interactive dashboards, and summarize pull requests")
+        
+        with gr.Tab("Repository Analysis"):
+            with gr.Row():
+                with gr.Column():
+                    owner_input = gr.Textbox(label="Repository Owner (Username/Organization)")
+                    repo_input = gr.Textbox(label="Repository Name")
+                    github_token = gr.Textbox(label="GitHub Token (Optional)", type="password")
+                    
+                    with gr.Accordion("Advanced Settings (Optional)", open=False):
+                        neo4j_uri = gr.Textbox(label="Neo4j URI")
+                        neo4j_user = gr.Textbox(label="Neo4j Username")
+                        neo4j_password = gr.Textbox(label="Neo4j Password", type="password")
+                        gemini_api_key = gr.Textbox(label="Google API Key (for Gemini)", type="password")
+                    
+                    analyze_btn = gr.Button("Analyze Repository")
+                
+                with gr.Column():
+                    report_output = gr.Markdown(label="Analysis Report")
+                    dashboard_output = gr.HTML(label="Dashboard Preview")
+            
+            analyze_btn.click(
+                analyze_repository,
+                inputs=[
+                    owner_input, repo_input, github_token,
+                    neo4j_uri, neo4j_user, neo4j_password,
+                    gemini_api_key
+                ],
+                outputs=[dashboard_output, report_output]
+            )
+        
+        with gr.Tab("PR Summarizer"):
+            with gr.Row():
+                with gr.Column():
+                    pr_owner_input = gr.Textbox(label="Repository Owner")
+                    pr_repo_input = gr.Textbox(label="Repository Name")
+                    pr_number_input = gr.Number(label="PR Number", precision=0)
+                    pr_role_input = gr.Dropdown(
+                        choices=["Developer", "Manager", "Team Lead", "Product Owner", "Program Manager", "General"],
+                        label="Your Role"
+                    )
+                    pr_github_token = gr.Textbox(label="GitHub Token (Optional)", type="password")
+                    pr_gemini_api_key = gr.Textbox(label="Google API Key (Required for Gemini)", type="password")
+                    
+                    summarize_btn = gr.Button("Summarize PR")
+                    
+                with gr.Column():
+                    pr_summary_output = gr.Markdown(label="PR Summary")
+            
+            summarize_btn.click(
+                summarize_pr,
+                inputs=[
+                    pr_owner_input, pr_repo_input, pr_number_input,
+                    pr_role_input, pr_github_token, pr_gemini_api_key
+                ],
+                outputs=pr_summary_output
+            )
+        
+    return app
+
+# Main function to run the app
+def main():
+    """Run the GitHub Repository Analyzer with Gradio interface."""
+    # Load environment variables
+    load_dotenv()
     
+    # Create and launch the Gradio interface
+    app = create_gradio_interface()
+    app.launch(share=True, debug=True)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file