diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -5,98 +5,33 @@ import base64
 import re
 import ast
 import networkx as nx
-# Make sure radon is installed: pip install radon
-try:
-    import radon.metrics as metrics
-    import radon.complexity as complexity
-except ImportError:
-    print("Warning: Radon library not found. Code complexity analysis will be limited.")
-    # Provide dummy functions if radon is not available
-    class DummyRadon:
-        def cc_visit(self, *args, **kwargs): return 0
-        def cc_visit_ast(self, *args, **kwargs): return 0
-        def mi_visit(self, *args, **kwargs): return None
-    metrics = DummyRadon()
-    complexity = DummyRadon()
-
+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
-# Ensure IPython is available or handle its absence
-try:
-    from IPython.display import display, Markdown, HTML
-    IPYTHON_AVAILABLE = True
-except ImportError:
-    IPYTHON_AVAILABLE = False
-    # Define dummy display functions if not in IPython
-    def display(*args, **kwargs): print(*args)
-    def Markdown(text): print(f"--- Markdown ---\n{text}\n---------------")
-    def HTML(text): print(f"----- HTML -----\n{text}\n--------------")
-
 import numpy as np
-# Ensure PyGithub is installed: pip install PyGithub
-try:
-    from github import Github, GithubException
-except ImportError:
-    print("Warning: PyGithub library not found. Some features might be limited.")
-    Github = None # Set to None if not available
-    GithubException = Exception # Use base Exception
-
+from github import Github, GithubException
 import time
-# Ensure python-dotenv is installed: pip install python-dotenv
-try:
-    from dotenv import load_dotenv
-except ImportError:
-    print("Warning: python-dotenv not found. .env file will not be loaded.")
-    def load_dotenv(): pass # Dummy function
+from dotenv import load_dotenv
 
-# Import Neo4j and Gemini libraries
-# Ensure neo4j is installed: pip install neo4j
-try:
-    from neo4j import GraphDatabase, basic_auth
-except ImportError:
-    print("Warning: Neo4j library not found. Graph features will be disabled.")
-    GraphDatabase = None # Set to None
-    basic_auth = None
+# Visualization imports
+import vizro.plotly.express as px
+import vizro
+import vizro.models as vzm
+import plotly.graph_objects as go
+import gradio as gr
+from pyvis.network import Network
 
-# Ensure google-generativeai is installed: pip install google-generativeai
+# Google Gemini AI (optional)
 try:
     import google.generativeai as genai
+    GEMINI_AVAILABLE = True
 except ImportError:
-    print("Warning: google-generativeai library not found. Gemini features will be disabled.")
-    genai = None # Set to None
+    GEMINI_AVAILABLE = False
+    print("Google Generative AI package not found. PR summarization feature will be disabled.")
 
-# Import Vizro and Gradio
-# Ensure vizro, vizro-plotly, plotly, gradio are installed
-# pip install vizro vizro-plotly plotly gradio pandas networkx matplotlib numpy
-try:
-    import vizro.plotly.express as px
-    import vizro
-    import vizro.models as vzm
-    import plotly.graph_objects as go
-except ImportError:
-    print("Critical Error: Vizro or Plotly libraries not found. Dashboard generation will fail.")
-    # Define dummy classes/functions to avoid NameErrors later, though functionality will be broken
-    class DummyVzm:
-        Card = lambda **kwargs: None
-        Graph = lambda **kwargs: None
-        Page = lambda **kwargs: None
-        Dashboard = lambda **kwargs: type('obj', (object,), {'save': lambda self, path: print(f"Vizro not installed, cannot save to {path}")})()
-    vzm = DummyVzm()
-    px = None
-    go = None
-    vizro = None
-
-try:
-    import gradio as gr
-except ImportError:
-    print("Critical Error: Gradio library not found. Cannot launch the UI.")
-    gr = None # Set to None
 
-
-# --- GitHubRepoInfo Class (Keep as provided, ensuring dependencies like PyGithub are handled) ---
 class GitHubRepoInfo:
     """Enhanced class to get comprehensive information about a GitHub repository."""
 
@@ -110,37 +45,23 @@ class GitHubRepoInfo:
         # Set up authentication
         if token:
             self.headers["Authorization"] = f"token {token}"
-            if Github: # Check if PyGithub was imported
-                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
-            else:
-                 print("Warning: PyGithub not installed. Cannot use authenticated PyGithub client.")
-                 self.github = None # Explicitly set to None
-
+            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}"
-            if Github:
-                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:
-                 print("Warning: PyGithub not installed. Cannot use authenticated PyGithub client.")
-                 self.github = None
+            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:
-            if Github:
-                self.github = Github() # Unauthenticated
-            else:
-                 print("Warning: PyGithub not installed. Cannot use authenticated PyGithub client.")
-                 self.github = None
-
+            self.github = Github() # Unauthenticated
 
         # Configure rate limit handling
         self.rate_limit_remaining = 5000 # Assume higher limit if authenticated
@@ -152,54 +73,25 @@ class GitHubRepoInfo:
                  self.rate_limit_remaining = rate_limit.core.remaining
                  self.rate_limit_reset = datetime.fromtimestamp(rate_limit.core.reset)
             except Exception as e:
-                 # Don't print warning if self.github is None
-                 if self.github is not None:
-                     print(f"Warning: Could not get initial rate limit from PyGithub: {e}")
-        # Check rate limit via REST if PyGithub failed or wasn't used
-        elif self.token:
-            try:
-                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"])
-                else:
-                    print(f"Warning: Could not get initial rate limit via REST: Status {response.status_code}")
-            except Exception as e:
-                print(f"Warning: Could not get initial rate limit via REST: {e}")
-
+                 print(f"Warning: Could not get initial rate limit from PyGithub: {e}")
 
     def _check_rate_limit(self):
         """Check API rate limit and wait if necessary."""
-        # Update rate limit info before checking
-        try:
-            response = requests.get(f"{self.base_url}/rate_limit", headers=self.headers)
-            if response.status_code == 200:
-                rate_data = response.json()
-                # Ensure keys exist before accessing
-                core_limits = rate_data.get("resources", {}).get("core", {})
-                self.rate_limit_remaining = core_limits.get("remaining", self.rate_limit_remaining) # Use old value if missing
-                reset_timestamp = core_limits.get("reset")
-                if reset_timestamp:
-                     self.rate_limit_reset = datetime.fromtimestamp(reset_timestamp)
-            # No else needed, just use previous values if update fails
-        except Exception as e:
-            print(f"Warning: Failed to update rate limit info: {e}")
-            # Proceed with potentially outdated values
-
         if self.rate_limit_remaining <= 10:
             reset_time = self.rate_limit_reset
-            # Use timezone-naive comparison
             current_time = datetime.now()
 
             if reset_time > current_time:
                 wait_time = (reset_time - current_time).total_seconds() + 10  # Add buffer
-                if wait_time > 0: # Only wait if reset time is in the future
-                     print(f"Rate limit nearly exhausted. Waiting {wait_time:.0f} seconds for reset.")
-                     time.sleep(wait_time)
-                     # Re-fetch rate limit after waiting
-                     self._check_rate_limit()
+                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."""
@@ -208,41 +100,33 @@ class GitHubRepoInfo:
 
         items = []
         page = 1
-        # Use a smaller default per_page to be safer with rate limits if unauthenticated
-        default_per_page = 100 if self.token else 30
-        per_page = min(100, params.get("per_page", default_per_page))
+        per_page = min(100, params.get("per_page", 30))
         params["per_page"] = per_page
 
         while True:
-            self._check_rate_limit() # Check before each request
+            self._check_rate_limit()
 
             params["page"] = page
-            try:
-                 response = requests.get(url, headers=self.headers, params=params, timeout=20) # Add timeout
-                 response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+            response = requests.get(url, headers=self.headers, params=params)
 
-                 page_items = response.json()
-                 if not page_items: # No more items
+            if response.status_code == 200:
+                page_items = response.json()
+                if not page_items:
                     break
 
-                 items.extend(page_items)
-                 page += 1
+                items.extend(page_items)
+                page += 1
 
-                 # Check if we've reached the requested limit
-                 if max_items and len(items) >= max_items:
+                # 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:
+                # Check if we've reached the end (GitHub returns fewer items than requested)
+                if len(page_items) < per_page:
                     break
-
-            except requests.exceptions.RequestException as e:
-                 print(f"Error during paginated request to {url} (page {page}): {e}")
-                 # Decide whether to break or retry (here we break)
-                 break
-            except json.JSONDecodeError as e:
-                 print(f"Error decoding JSON response from {url} (page {page}): {e}")
-                 break
+            else:
+                print(f"Error {response.status_code}: {response.text}")
+                break
 
         return items
 
@@ -250,90 +134,96 @@ class GitHubRepoInfo:
         """Get basic repository information."""
         self._check_rate_limit()
         url = f"{self.base_url}/repos/{owner}/{repo}"
-        try:
-            response = requests.get(url, headers=self.headers, timeout=15)
-            response.raise_for_status() # Check for 4xx/5xx errors
+        response = requests.get(url, headers=self.headers)
+
+        if response.status_code == 200:
             return response.json()
-        except requests.exceptions.RequestException as e:
-            print(f"Error getting repository info for {owner}/{repo}: {e}")
-            return None # Return None on failure
+        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)
 
-    # ... (other GitHubRepoInfo methods - assume they return sensible defaults like [] or {} on failure) ...
-    # --- Add safe defaults to methods that might return None unexpectedly ---
     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"
-        try:
-            response = requests.get(url, headers=self.headers, timeout=15)
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            print(f"Error getting languages for {owner}/{repo}: {e}")
-            return {} # Return empty dict on failure
+        response = requests.get(url, headers=self.headers)
 
-    def get_contributors(self, owner, repo, max_contributors=None):
-        """Get repository contributors with pagination support."""
-        url = f"{self.base_url}/repos/{owner}/{repo}/contributors"
-        # _paginated_get should already handle errors and return a list
-        return self._paginated_get(url, max_items=max_contributors) or [] # Ensure list return
+        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) or [] # Ensure list return
-
-    def _get_stats_with_retry(self, url):
-        """Helper for stats endpoints that might return 202."""
-        retries = 3
-        delay = 5 # Initial delay in seconds
-        for i in range(retries):
-            self._check_rate_limit()
-            try:
-                response = requests.get(url, headers=self.headers, timeout=30) # Longer timeout for stats
-                if response.status_code == 200:
-                    return response.json()
-                elif response.status_code == 202 and i < retries - 1:
-                    print(f"GitHub is computing statistics for {url.split('/stats/')[1]}, waiting {delay}s and retrying ({i+1}/{retries})...")
-                    time.sleep(delay)
-                    delay *= 2 # Exponential backoff
-                    continue
-                elif response.status_code == 204: # No content, valid response but empty data
-                    print(f"No content (204) returned for {url.split('/stats/')[1]}. Returning empty list.")
-                    return []
-                else:
-                    print(f"Error getting stats from {url}: Status {response.status_code}, Body: {response.text[:200]}")
-                    return [] # Return empty list on other errors
-            except requests.exceptions.RequestException as e:
-                 print(f"Request error getting stats from {url}: {e}")
-                 return [] # Return empty list on request error
-        print(f"Failed to get stats from {url} after {retries} retries.")
-        return [] # Return empty list after all retries fail
+        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"
-        return self._get_stats_with_retry(url)
+        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"
-        return self._get_stats_with_retry(url)
+        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 []
 
     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"
-        return self._get_stats_with_retry(url)
+        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) or []
+        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) or []
+        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."""
@@ -341,7 +231,54 @@ class GitHubRepoInfo:
         if params is None:
             params = {}
         params["state"] = state
-        return self._paginated_get(url, params=params, max_items=max_issues) or []
+        return self._paginated_get(url, params=params, max_items=max_issues)
+
+    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
+
+        return {
+            'created': created_counts,
+            'closed': closed_counts,
+            'resolution_times': resolution_times,
+            'labels': dict(label_counts)
+        }
 
     def get_pull_requests(self, owner, repo, state="all", max_prs=None, params=None):
         """Get repository pull requests with enhanced filtering."""
@@ -349,7 +286,71 @@ class GitHubRepoInfo:
         if params is None:
             params = {}
         params["state"] = state
-        return self._paginated_get(url, params=params, max_items=max_prs) or []
+        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."""
@@ -359,17 +360,13 @@ class GitHubRepoInfo:
         if ref:
             params["ref"] = ref
 
-        try:
-            response = requests.get(url, headers=self.headers, params=params, timeout=15)
-            response.raise_for_status()
+        response = requests.get(url, headers=self.headers, params=params)
+
+        if response.status_code == 200:
             return response.json()
-        except requests.exceptions.RequestException as e:
-             # Handle 404 specifically for contents
-             if hasattr(e, 'response') and e.response is not None and e.response.status_code == 404:
-                 print(f"Contents not found at path '{path}' in {owner}/{repo}.")
-             else:
-                 print(f"Error getting contents for {owner}/{repo} at path '{path}': {e}")
-             return [] # Return empty list on failure
+        else:
+            print(f"Error getting contents: {response.status_code}")
+            return []
 
     def get_readme(self, owner, repo, ref=None):
         """Get repository README file."""
@@ -379,27 +376,20 @@ class GitHubRepoInfo:
         if ref:
             params["ref"] = ref
 
-        try:
-            response = requests.get(url, headers=self.headers, params=params, timeout=15)
-            response.raise_for_status()
+        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 {
-                        "name": data.get("name", "README"),
-                        "path": data.get("path", "README.md"),
-                        "content": content
-                    }
-                except (UnicodeDecodeError, base64.binascii.Error) as decode_error:
-                    print(f"Error decoding README content: {decode_error}")
-                    return None # Cannot decode
-            return None # No content key
-        except requests.exceptions.RequestException as e:
-            if hasattr(e, 'response') and e.response is not None and e.response.status_code == 404:
-                print(f"README not found for {owner}/{repo}.")
-            else:
-                print(f"Error getting README for {owner}/{repo}: {e}")
+                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):
@@ -410,310 +400,440 @@ class GitHubRepoInfo:
         if ref:
             params["ref"] = ref
 
-        try:
-            response = requests.get(url, headers=self.headers, params=params, timeout=15)
-            response.raise_for_status()
+        response = requests.get(url, headers=self.headers, params=params)
+
+        if response.status_code == 200:
             data = response.json()
-            if data.get("type") == "file" and data.get("content"):
+            if data.get("content"):
                 try:
                     content = base64.b64decode(data["content"]).decode("utf-8")
                     return content
-                except (UnicodeDecodeError, base64.binascii.Error):
-                    # Don't print error here, return indicator
+                except UnicodeDecodeError:
                     return "[Binary file content not displayed]"
-            elif data.get("type") != "file":
-                 print(f"Path '{path}' is not a file.")
-                 return None
-            else:
-                 # File exists but no content? Unlikely but handle.
-                 return "" # Return empty string for empty file
-        except requests.exceptions.RequestException as e:
-             if hasattr(e, 'response') and e.response is not None and e.response.status_code == 404:
-                 print(f"File not found at path '{path}' in {owner}/{repo}.")
-             else:
-                print(f"Error getting file content for {owner}/{repo}, path '{path}': {e}")
-             return None
-
-    # --- Methods like is_text_file, analyze_ast, analyze_js_ts are generally okay ---
-    # ... (keep them as they are) ...
-
-    # --- Ensure get_all_text_files handles errors from get_contents/get_file_content ---
-    def get_all_text_files(self, owner, repo, path="", max_files=50, ref=None, _current_count=0):
-        """Get content of all text files in the repository (with limit)."""
-        if _current_count >= max_files:
-            return [], _current_count
+            return None
+        else:
+            print(f"Error getting file content: {response.status_code}")
+            return None
 
-        # Get contents for the current path
-        contents = self.get_contents(owner, repo, path, ref) # Returns [] on error
-        text_files = []
-        file_count = _current_count
+    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'
+        ]
 
-        if not isinstance(contents, list):
-            print(f"Warning: get_contents did not return a list for path '{path}'. Skipping.")
-            return [], file_count
+        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
 
-        # Process current directory
         for item in contents:
             if file_count >= max_files:
                 break
 
-            # Ensure item is a dictionary and has 'type' and 'name'
-            if not isinstance(item, dict) or 'type' not in item or 'name' not in item:
-                 print(f"Warning: Skipping malformed item in contents: {item}")
-                 continue
-
-            item_path = item.get("path") # Get path safely
-            if not item_path:
-                 print(f"Warning: Skipping item with missing path: {item}")
-                 continue
+            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
+
+    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)
-                # Check if content is valid text (not None or binary indicator)
+                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,
+                        "path": item["path"],
                         "content": content
                     })
                     file_count += 1
             elif item["type"] == "dir":
                 # Recursively get text files from subdirectories
-                if file_count < max_files:
-                    try:
-                        subdir_files, file_count = self.get_all_text_files(
-                            owner, repo, item_path, max_files, ref, file_count
-                        )
-                        text_files.extend(subdir_files)
-                    except Exception as e_rec:
-                         print(f"Error processing subdirectory '{item_path}': {e_rec}")
-                         # Continue with other items in the current directory
-
-        return text_files, file_count # Return count for recursive calls
-
-    # --- Ensure get_documentation_files handles errors ---
+                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 = [
-            "README.md", "CONTRIBUTING.md", "CODE_OF_CONDUCT.md", "SECURITY.md",
-            "SUPPORT.md", # Files first
-            "docs", "doc", "documentation", "wiki", # Common Dirs
+            "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 = []
 
-        # 1. Get top-level files first
-        root_contents = self.get_contents(owner, repo, "", ref)
-        if isinstance(root_contents, list):
-             for item in root_contents:
-                 if isinstance(item, dict) and item.get("type") == "file" and item.get("name") in doc_paths:
-                     path = item.get("path")
-                     if path:
-                         content = self.get_file_content(owner, repo, path, ref)
-                         if content and content != "[Binary file content not displayed]":
-                             doc_files.append({
-                                 "name": item["name"],
-                                 "path": path,
-                                 "content": content
-                             })
-
-        # 2. Check specific doc directories
-        doc_dirs_to_check = ["docs", "doc", "documentation", "wiki", ".github"]
-        for doc_dir in doc_dirs_to_check:
+        # Try to get each documentation file/directory
+        for path in doc_paths:
             try:
-                dir_contents = self.get_contents(owner, repo, doc_dir, ref)
-                if isinstance(dir_contents, list): # It's a directory
-                    for item in dir_contents:
-                        if isinstance(item, dict) and item.get("type") == "file":
-                             item_name = item.get("name", "").lower()
-                             item_path = item.get("path")
-                             if item_path and item_name.endswith((".md", ".rst", ".txt")):
-                                 content = self.get_file_content(owner, repo, item_path, ref)
-                                 if content and content != "[Binary file content not displayed]":
-                                     doc_files.append({
-                                         "name": item["name"],
-                                         "path": item_path,
-                                         "content": content
-                                     })
-            except Exception as e:
-                 print(f"Error processing documentation path '{doc_dir}': {e}")
-                 continue # Skip this path
+                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
 
-    # ... (rest of GitHubRepoInfo, display methods, etc. - keep as provided but be mindful of data access in display) ...
-    # Add specific error handling in display methods if needed, though Gradio errors often hide underlying data issues.
-    def get_all_info(self, owner, repo):
-        """Get comprehensive information about a repository with enhanced metrics."""
-        print(f"--- Fetching data for {owner}/{repo} ---")
-        result = {
-            "timestamp": datetime.now().isoformat()
-        }
-
-        print("Getting basic repo info...")
-        basic_info = self.get_repo_info(owner, repo)
-        if not basic_info:
-            print(f"CRITICAL: Could not retrieve basic repository information for {owner}/{repo}. Aborting analysis.")
-            return None # Cannot proceed without basic info
-        result["basic_info"] = basic_info
-
-        print("Getting languages...")
-        result["languages"] = self.get_languages(owner, repo) # Returns {} on error
-        print("Getting contributors...")
-        result["contributors"] = self.get_contributors(owner, repo, max_contributors=30) # Returns [] on error
-        print("Getting recent commits...")
-        result["recent_commits"] = self.get_commits(owner, repo, max_commits=30) # Returns [] on error
-        print("Getting branches...")
-        result["branches"] = self.get_branches(owner, repo) # Returns [] on error
-        print("Getting releases...")
-        result["releases"] = self.get_releases(owner, repo, max_releases=10) # Returns [] on error
-        print("Getting open issues...")
-        result["open_issues"] = self.get_issues(owner, repo, state="open", max_issues=50) # Returns [] on error
-        print("Getting open pull requests...")
-        result["open_pull_requests"] = self.get_pull_requests(owner, repo, state="open", max_prs=50) # Returns [] on error
-        print("Getting root contents...")
-        result["root_contents"] = self.get_contents(owner, repo) # Returns [] on error
-
-        print("Analyzing repository content (README, Docs, Code Files)...")
-        # This relies on other methods returning sensible defaults
         try:
-             # Call get_all_text_files outside get_repo_text_summary to pass count correctly
-             all_text_files_content, _ = self.get_all_text_files(owner, repo, max_files=30)
-             # Pass the fetched content to get_repo_text_summary to avoid redundant API calls
-             result["text_content"] = self.get_repo_text_summary(owner, repo, pre_fetched_files=all_text_files_content)
-        except Exception as e:
-             print(f"Error during text content analysis: {e}")
-             result["text_content"] = {"error": str(e)} # Store error indicator
+            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
+                    })
 
-        print("Analyzing repository activity over time...")
-        # This relies on stats methods returning [] on error/202 timeout
-        try:
-            result["temporal_analysis"] = self.get_temporal_analysis(owner, repo)
-        except Exception as e:
-            print(f"Error during temporal analysis: {e}")
-            result["temporal_analysis"] = {"error": str(e)} # Store error indicator
+                # 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}")
 
-        print(f"--- Finished fetching data for {owner}/{repo} ---")
-        return result
+            # Calculate overall code complexity
+            code_complexity = complexity.cc_visit_ast(tree)
 
-    # Modify get_repo_text_summary to accept pre-fetched files
-    def get_repo_text_summary(self, owner, repo, max_files=25, pre_fetched_files=None):
-        """Extract and summarize text content from the repository with improved metrics."""
-        # Get README
-        readme = self.get_readme(owner, repo) # Returns None on error
+            # 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
+                }
+            }
 
-        # Get documentation
-        docs = self.get_documentation_files(owner, repo) # Returns [] on error
+        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
 
-        # Get key code files if not provided
-        if pre_fetched_files is None:
-            print("Fetching text files within get_repo_text_summary...")
-            text_files, _ = self.get_all_text_files(owner, repo, max_files=max_files) # Returns [] on error
-        else:
-            print("Using pre-fetched text files in get_repo_text_summary.")
-            text_files = pre_fetched_files # Use the provided list
+    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
 
-        # Analyze code files
-        code_summary = {}
-        complexity_metrics = {
-            'cyclomatic_complexity': [],
-            'maintainability_index': [],
-            'comment_ratios': []
+        # More sophisticated regex patterns for JS/TS analysis
+        results = {
+            'functions': [],
+            'classes': [],
+            'imports': [],
+            'exports': [],
+            'hooks': []  # For React hooks
         }
 
-        for file in text_files:
-            # Basic check for file structure
-            if not isinstance(file, dict) or 'name' not in file or 'content' not in file or 'path' not in file:
-                 print(f"Skipping malformed file data in text summary: {file}")
-                 continue
+        # 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*\(([^)]*)\)'
+        ]
 
-            ext = os.path.splitext(file["name"])[1].lower()
-            if ext in ['.py', '.js', '.ts', '.jsx', '.tsx']: # Add other relevant code extensions if needed
-                 try:
-                    file_summary = self.extract_code_summary(file["content"], file["path"])
-                    if file_summary: # Ensure summary generation didn't fail
-                        code_summary[file["path"]] = file_summary
-
-                        # Collect complexity metrics safely
-                        if file_summary.get('complexity'):
-                             cc = file_summary['complexity'].get('overall')
-                             # Ensure cc is a number before appending
-                             if isinstance(cc, (int, float)):
-                                complexity_metrics['cyclomatic_complexity'].append((file["path"], cc))
-
-                             mi = file_summary['complexity'].get('maintainability_index')
-                             # Ensure mi is a number before appending
-                             if isinstance(mi, (int, float)):
-                                complexity_metrics['maintainability_index'].append((file["path"], mi))
-
-                        if file_summary.get('metrics'):
-                             comment_ratio = file_summary['metrics'].get('comment_ratio')
-                             # Ensure ratio is a number before appending
-                             if isinstance(comment_ratio, (int, float)):
-                                complexity_metrics['comment_ratios'].append((file["path"], comment_ratio))
-                 except Exception as e_sum:
-                     print(f"Error extracting code summary for {file.get('path', 'unknown file')}: {e_sum}")
-
-        # Analyze dependencies (can be slow, consider limiting files further if needed)
-        # Use the already fetched text_files for dependency analysis
-        dependencies = self.analyze_dependencies(owner, repo, pre_fetched_code_files=text_files)
+        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+)?'
+        ]
 
-        # Summarize repository content by file type
-        file_types = defaultdict(int)
-        for file in text_files:
-             if isinstance(file, dict) and 'name' in file: # Check again
-                ext = os.path.splitext(file["name"])[1].lower()
-                if ext: # Avoid counting files with no extension
-                    file_types[ext] += 1
-
-        # Calculate aggregate code metrics safely
-        total_code_lines = 0
-        total_comment_lines = 0
-        analyzed_code_files = 0
-        for path, summary in code_summary.items():
-            if summary and summary.get('metrics'):
-                analyzed_code_files += 1
-                total_code_lines += summary['metrics'].get('code_lines', 0) or 0
-                total_comment_lines += summary['metrics'].get('comment_lines', 0) or 0
+        for pattern in export_patterns:
+            for match in re.finditer(pattern, code):
+                if match.group(1):
+                    results['exports'].append(match.group(1))
 
-        aggregate_metrics = {
-            'total_files_analyzed': len(text_files), # All text files fetched
-            'code_files_summarized': analyzed_code_files, # Files where summary succeeded
-            '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 results
 
-        return {
-            "readme": readme, # Can be None
-            "documentation": docs, # Should be list
-            "code_summary": code_summary, # Dict of summaries
-            "complexity_metrics": complexity_metrics, # Dict of lists
-            "dependencies": dependencies, # Dict
-            "file_type_counts": dict(file_types), # Dict
-            "aggregate_metrics": aggregate_metrics, # Dict
-            "text_files": text_files # List of fetched files
+    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
         }
 
+        # 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"]
+
+                # 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)
+            }
+
+        return summary
 
-    # Modify analyze_dependencies to accept pre-fetched files
-    def analyze_dependencies(self, owner, repo, max_files=100, pre_fetched_code_files=None):
+    def analyze_dependencies(self, owner, repo, max_files=100):
         """Analyze code dependencies across the repository."""
-        if pre_fetched_code_files is None:
-             # Get Python and JavaScript files if not provided
-             print("Fetching text files within analyze_dependencies...")
-             text_files, _ = self.get_all_text_files(owner, repo, max_files=max_files)
-             # Filter for Python and JS/TS files
-             code_files = [f for f in text_files if isinstance(f, dict) and f.get("name", "").endswith(('.py', '.js', '.ts', '.jsx', '.tsx'))]
-        else:
-             print("Using pre-fetched files in analyze_dependencies.")
-             # Assume pre_fetched_code_files are already filtered if needed, or filter here
-             code_files = [f for f in pre_fetched_code_files if isinstance(f, dict) and f.get("name", "").endswith(('.py', '.js', '.ts', '.jsx', '.tsx'))]
+        # Get Python and JavaScript files
+        text_files = self.get_all_text_files(owner, repo, max_files=max_files)
 
+        # 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 = {
@@ -725,1534 +845,1114 @@ class GitHubRepoInfo:
         # Extract module names from file paths
         file_to_module = {}
         for file in code_files:
-             # Add checks here too
-             if not isinstance(file, dict) or 'path' not in file or 'content' not in file: continue
-             # 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
-             try:
-                summary = self.extract_code_summary(file["content"], file["path"])
-                if not summary: continue # Skip if summary failed
-
-                if file.get("name", "").endswith('.py'):
-                    for function in summary.get("functions", []):
-                        # Ensure function is a string before adding
-                        if isinstance(function, str):
-                            dependencies['modules'][file["path"]].add(f"{module_path}.{function}")
-                    for class_name in summary.get("classes", []):
-                         # Ensure class_name is a string before adding
-                        if isinstance(class_name, str):
-                            dependencies['modules'][file["path"]].add(f"{module_path}.{class_name}")
-                else:  # JS/TS files
-                    for export in summary.get("exports", []):
-                         # Ensure export is a string before adding
-                        if isinstance(export, str):
-                            dependencies['modules'][file["path"]].add(export)
-             except Exception as e_dep_mod:
-                 print(f"Error processing module definitions for {file.get('path', 'unknown file')}: {e_dep_mod}")
-
+            # 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:
-             if not isinstance(file, dict) or 'path' not in file or 'content' not in file: continue
-             try:
-                summary = self.extract_code_summary(file["content"], file["path"])
-                if not summary: continue
-
-                for imp in summary.get("imports", []):
-                    # Ensure import is a string
-                    if not isinstance(imp, str) or not imp: continue
-
-                    # Check if this is an internal import
-                    is_internal = False
-                    target_dep_path = None # Store the resolved internal path
-
-                    if file.get("name","").endswith('.py'):
-                        # For Python, check if the import matches any module path
-                        # Normalize potential relative imports starting with '.'
-                        current_module_parts = file_to_module[file["path"]].split('.')
-                        if imp.startswith('.'):
-                            # Resolve relative import (basic attempt)
-                            level = 0
-                            while imp.startswith('.'):
-                                level += 1
-                                imp = imp[1:]
-                            base_parts = current_module_parts[:-level] if level > 0 else current_module_parts[:-1] # Go up levels or stay in package
-                            resolved_imp = '.'.join(base_parts + [imp] if imp else base_parts) # Handle 'from . import foo' vs 'from ..bar import baz'
-                        else:
-                            resolved_imp = imp # Absolute import
-
-                        # Check against known module paths
-                        for f_path, m_path in file_to_module.items():
-                            # Exact match or parent package match
-                            if resolved_imp == m_path or resolved_imp.startswith(f"{m_path}."):
-                                target_dep_path = f_path
-                                break
-                            # Check if import is trying to import a specific module file directly
-                            # e.g. import mypackage.module -> check if file path matches mypackage/module.py
-                            potential_file_path = resolved_imp.replace('.', '/') + '.py'
-                            if potential_file_path == f_path:
-                                target_dep_path = f_path
-                                break
-
-                    else: # JS/TS
-                        # For JS/TS, check relative imports or alias paths (more complex, basic check here)
-                        if imp.startswith('./') or imp.startswith('../') or imp.startswith('@/'): # Basic checks
-                            is_internal = True # Assume internal for now
-                            # Basic resolution attempt
-                            src_dir = os.path.dirname(file["path"])
-                            target_path_base = os.path.normpath(os.path.join(src_dir, imp))
-
-                            # Try adding common extensions
-                            for ext in ['.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts']:
-                                test_path = f"{target_path_base}{ext}"
+            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:
+                    # 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:
-                                    target_dep_path = test_path
+                                    dependencies['internal'][file["path"]].add(test_path)
                                     break
-                                # Check path without extension too (might be dir import)
-                                if target_path_base in file_to_module:
-                                     target_dep_path = target_path_base
-                                     break
-
-
-                    # If a target internal path was found, add the dependency
-                    if target_dep_path:
-                        # Ensure the target path actually exists in our list of files
-                        if target_dep_path in file_to_module:
-                            dependencies['internal'][file["path"]].add(target_dep_path)
-                            is_internal = True # Confirm it was internal
-
-                    # If not internal, consider it external
-                    if not is_internal:
-                        # Clean up the import name (remove relative path parts, take package name)
-                        # Handle scoped packages like @angular/core -> @angular/core
-                        # Handle imports like 'react-dom/client' -> react-dom
-                        if '/' in imp and not imp.startswith('.') and not imp.startswith('@'):
-                             package_base = imp.split('/')[0]
-                        elif imp.startswith('@'):
-                             parts = imp.split('/')
-                             package_base = '/'.join(parts[:2]) if len(parts) >= 2 else parts[0] # Keep scope like @scope/package
-                        else:
-                             package_base = imp
-
-                        # Add only non-empty strings
-                        if package_base:
-                             dependencies['external'][file["path"]].add(package_base)
-             except Exception as e_dep_ana:
-                 print(f"Error processing dependencies for {file.get('path', 'unknown file')}: {e_dep_ana}")
 
+                # 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
+
+    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 {
+            "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
+        }
 
-    # --- get_temporal_analysis: Ensure sub-methods return [] and handle potential errors ---
     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) or [] # Ensure list
+        commit_activity = self.get_commit_activity(owner, repo)
 
         # Get code frequency (additions/deletions over time)
-        code_frequency = self.get_code_frequency(owner, repo) or [] # Ensure list
+        code_frequency = self.get_code_frequency(owner, repo)
 
         # Get contributor activity
-        contributor_activity = self.get_contributor_activity(owner, repo) or [] # Ensure list
-
-        # Get issue and PR timelines (These methods already return dicts with lists/values)
-        # Add error handling around the calls themselves
-        try:
-            issue_timeline = self.get_issue_timeline(owner, repo)
-        except Exception as e:
-            print(f"Error getting issue timeline: {e}")
-            issue_timeline = {} # Default empty dict
+        contributor_activity = self.get_contributor_activity(owner, repo)
 
-        try:
-            pr_timeline = self.get_pr_timeline(owner, repo)
-        except Exception as e:
-            print(f"Error getting PR timeline: {e}")
-            pr_timeline = {} # Default empty dict
+        # 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 safely
+        # Process data for visualization
         # - Weekly commit counts
         weekly_commits = []
-        if isinstance(commit_activity, list): # Check if list
-             for week in commit_activity:
-                 # Check if item is a dict with expected keys
-                 if isinstance(week, dict) and 'week' in week and 'total' in week and 'days' in week:
-                     try:
-                         date = datetime.fromtimestamp(week['week'])
-                         weekly_commits.append({
-                             'date': date.strftime('%Y-%m-%d'),
-                             'total': int(week['total']), # Ensure integer
-                             'days': week['days'] # Daily breakdown within the week
-                         })
-                     except (TypeError, ValueError) as e:
-                         print(f"Skipping invalid commit activity week data: {week}, Error: {e}")
-                 else:
-                     print(f"Skipping malformed commit activity week data: {week}")
-        else:
-             print(f"Warning: Commit activity data is not a list: {type(commit_activity)}")
-
+        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 isinstance(code_frequency, list): # Check if list
-             for item in code_frequency:
-                 # Check if item is a list/tuple of 3 numbers
-                 if isinstance(item, (list, tuple)) and len(item) == 3:
-                     try:
-                         date = datetime.fromtimestamp(item[0])
-                         additions = int(item[1])
-                         deletions = int(item[2]) # Keep positive for calculation
-                         weekly_code_changes.append({
-                             'date': date.strftime('%Y-%m-%d'),
-                             'additions': additions,
-                             'deletions': deletions # Store as positive deletions
-                         })
-                     except (TypeError, ValueError, IndexError) as e:
-                         print(f"Skipping invalid code frequency data: {item}, Error: {e}")
-                 else:
-                     print(f"Skipping malformed code frequency data: {item}")
-        else:
-             print(f"Warning: Code frequency data is not a list: {type(code_frequency)}")
-
+        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 isinstance(contributor_activity, list): # Check if list
+        if contributor_activity:
             for contributor in contributor_activity:
-                 # Check structure
-                 if (isinstance(contributor, dict) and
-                     'author' in contributor and isinstance(contributor['author'], dict) and 'login' in contributor['author'] and
-                     'weeks' in contributor and isinstance(contributor['weeks'], list)):
-
-                     author = contributor['author']['login']
-                     weeks_data = contributor['weeks']
-
-                     if author not in contributor_timeline:
-                         contributor_timeline[author] = []
-
-                     for week in weeks_data:
-                         # Check week structure and values
-                         if (isinstance(week, dict) and all(k in week for k in ['w', 'c', 'a', 'd']) and
-                             isinstance(week['c'], int) and week['c'] >= 0): # Check commit count is valid non-negative int
-
-                             if week['c'] > 0:  # Only include weeks with commits
-                                try:
-                                    date = datetime.fromtimestamp(week['w'])
-                                    contributor_timeline[author].append({
-                                        'date': date.strftime('%Y-%m-%d'),
-                                        'commits': int(week['c']),
-                                        'additions': int(week['a']),
-                                        'deletions': int(week['d'])
-                                    })
-                                except (TypeError, ValueError) as e:
-                                    print(f"Skipping invalid contributor week data for {author}: {week}, Error: {e}")
-                         # No else needed, just skip malformed week data silently or add print if desired
-                 else:
-                     print(f"Skipping malformed contributor activity data: {contributor}")
-        else:
-             print(f"Warning: Contributor activity data is not a list: {type(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
+        }
 
-        # Ensure issue/pr timelines are dicts before returning
-        issue_timeline = issue_timeline if isinstance(issue_timeline, dict) else {}
-        pr_timeline = pr_timeline if isinstance(pr_timeline, dict) else {}
+    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 result["basic_info"]:
+            print(f"Could not retrieve repository information for {owner}/{repo}")
+            return None
 
+        print("Getting repository statistics...")
 
-        return {
-            'weekly_commits': weekly_commits, # List
-            'weekly_code_changes': weekly_code_changes, # List
-            'contributor_timeline': contributor_timeline, # Dict
-            'issue_timeline': issue_timeline, # Dict
-            'pr_timeline': pr_timeline # Dict
-        }
+        # 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
 
-    # --- Pull Request Details (Ensure PyGithub is checked) ---
     def get_pull_request_details(self, owner, repo, pr_number):
         """Get detailed information for a specific Pull Request using PyGithub."""
-        if not self.github: # Check if PyGithub client was initialized
-            print("PyGithub client not initialized or installed. Cannot fetch PR details.")
-            # Fallback maybe? Try direct REST call if needed
-            # For now, return None
+        if not self.github:
+            print("PyGithub client not initialized. Cannot fetch PR details.")
             return None
 
         try:
-            # Ensure owner/repo are strings and pr_number is int
-            if not isinstance(owner, str) or not isinstance(repo, str):
-                 raise ValueError("Owner and repo must be strings.")
-            pr_number = int(pr_number)
-
             repo_obj = self.github.get_repo(f"{owner}/{repo}")
             pr = repo_obj.get_pull(pr_number)
 
-            # Extract relevant information into a dictionary safely
+            # Extract relevant information into a dictionary
             details = {
                 "number": pr.number,
-                "title": pr.title or "N/A",
-                "state": pr.state or "N/A", # 'open', 'closed'
-                "merged": pr.merged or False,
+                "title": pr.title,
+                "state": pr.state, # 'open', 'closed'
+                "merged": pr.merged,
                 "body": pr.body or "", # Ensure body is string
-                "url": pr.html_url or "N/A",
+                "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 if pr.commits is not None else 0,
-                "additions": pr.additions if pr.additions is not None else 0,
-                "deletions": pr.deletions if pr.deletions is not None else 0,
-                "changed_files_count": pr.changed_files if pr.changed_files is not None else 0,
-                "labels": [label.name for label in pr.labels] if pr.labels else [],
-                "assignees": [assignee.login for assignee in pr.assignees] if pr.assignees else [],
+                "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}.")
-            elif e.status == 401:
-                 print(f"Error: Unauthorized (401). Check your GitHub token permissions for {owner}/{repo}.")
-            elif e.status == 403:
-                 print(f"Error: Forbidden (403). Check token permissions or rate limits for {owner}/{repo}.")
             else:
-                print(f"GitHub API Error fetching PR #{pr_number} details: Status={e.status}, Data={e.data}")
+                print(f"Error fetching PR #{pr_number} details: {e}")
             return None
-        except ValueError as e: # Catch potential int conversion error
-             print(f"Error: Invalid PR number '{pr_number}'. Must be an integer. {e}")
-             return None
-        except Exception as e: # Catch any other unexpected errors
-            print(f"An unexpected error occurred fetching PR details for #{pr_number}: {e}")
+        except Exception as e:
+            print(f"An unexpected error occurred fetching PR details: {e}")
             return None
 
 
-# --- Colab Helpers (Keep 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)...
-# Use the provided robust JSON helpers
-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)
-                     # Ensure it's offset-naive or convert to UTC for ISO format
-                     if ts.tzinfo is not None:
-                          ts = ts.tz_convert(None) # Make naive if aware
-                     return ts.isoformat()
-                # Ensure standard datetime is offset-naive or convert to UTC
-                if obj.tzinfo is not None:
-                     obj = obj.astimezone(timezone.utc).replace(tzinfo=None) # Convert to UTC and make naive
-                return obj.isoformat()
-            elif isinstance(obj, (np.int64, np.int32)):
-                 return int(obj)
-            elif isinstance(obj, (np.float64, np.float32)):
-                 return float(obj)
-            elif isinstance(obj, np.bool_): # Handle numpy bool
-                 return bool(obj)
-            elif isinstance(obj, np.ndarray): # Handle numpy arrays
-                 return obj.tolist() # Convert to list
-            # Be careful with complex objects, might expose too much or fail
-            # Let the base class default method raise the TypeError for others
-            try:
-                return super(CustomJSONEncoder, self).default(obj)
-            except TypeError:
-                return str(obj) # Fallback to string representation for unknown types
-
-
-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):
-        # Convert set elements as well
-        return [convert_sets_to_lists(i) for i in sorted(list(obj))] # Sort for consistent output
-    elif isinstance(obj, tuple):
-        return tuple(convert_sets_to_lists(i) for i in obj)
-    # Handle numpy types specifically
-    elif isinstance(obj, (np.int64, np.int32, np.int_)):
-        return int(obj)
-    elif isinstance(obj, (np.float64, np.float32, np.float_)):
-         return float(obj)
-    elif isinstance(obj, np.datetime64):
-         # Consistent conversion to ISO format string (naive UTC)
-         ts = pd.to_datetime(obj).to_pydatetime() # Convert to standard datetime
-         if ts.tzinfo is not None:
-             ts = ts.astimezone(timezone.utc).replace(tzinfo=None)
-         return ts.isoformat() + "Z" # Add Z for UTC indication
-    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
-    elif isinstance(obj, pd.Timestamp): # Handle Pandas Timestamp
-        ts = obj.to_pydatetime()
-        if ts.tzinfo is not None:
-             ts = ts.astimezone(timezone.utc).replace(tzinfo=None)
-        return ts.isoformat() + "Z"
-    elif isinstance(obj, datetime): # Handle standard datetime
-        if obj.tzinfo is not None:
-             obj = obj.astimezone(timezone.utc).replace(tzinfo=None)
-        return obj.isoformat() + "Z"
-    else:
-        # Attempt to handle other non-serializable types gracefully
-        # Test if the specific object is serializable by default
-        try:
-            json.dumps(obj) # Test serialization
-            return obj # Return as is if serializable
-        except TypeError:
-            # If not serializable by default, convert to string as a fallback
-             print(f"Warning: Converting non-serializable type {type(obj)} to string.")
-             return str(obj)
-
-
-def save_json_to_colab(data, filename='/content/repo_info.json'):
-    """Save JSON data to a file in Colab and provide download option."""
-    # Deep conversion to handle nested structures and numpy types
-    try:
-        print("Converting data for JSON serialization...")
-        converted_data = convert_sets_to_lists(data)
-        print("Conversion complete. Saving JSON...")
-    except Exception as e:
-         print(f"Error during data conversion for JSON: {e}")
-         print("Attempting to save raw data (might fail)...")
-         # Fallback to trying without full conversion, might still fail
-         converted_data = data
-
-    try:
-        with open(filename, 'w', encoding='utf-8') as f:
-             # Use the custom encoder for any remaining types if conversion missed something
-            json.dump(converted_data, f, indent=2, cls=CustomJSONEncoder, ensure_ascii=False)
-        print(f"Data successfully saved to {filename}")
-        if IN_COLAB:
-            try:
-                print("To download the JSON file in Colab, run the following cell:")
-                print(f"from google.colab import files")
-                print(f"files.download('{filename}')")
-            except NameError: # files might not be imported if not in Colab context truly
-                pass
-    except TypeError as e:
-        print(f"Error saving JSON: {e}")
-        print("There might be non-serializable data types remaining even after conversion attempt.")
-        print("Consider inspecting the data structure for problematic types.")
-    except Exception as e:
-         print(f"An unexpected error occurred during JSON saving: {e}")
-
-
-# --- GraphRepoAnalyzer Class (Check initializations and data access) ---
-class GraphRepoAnalyzer:
-    """Integrates GitHub analysis with Neo4j and Gemini."""
-
-    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
+class RepoAnalyzer:
+    """Streamlined class to analyze GitHub repositories."""
+
+    def __init__(self, github_token=None, gemini_api_key=None):
+        """Initialize with GitHub and optional Gemini 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")
 
-        # Initialize github_analyzer using the potentially updated GitHubRepoInfo
-        # Pass the token directly
-        print("Initializing GitHubRepoInfo...")
+        # Initialize GitHub analyzer
         self.github_analyzer = GitHubRepoInfo(token=self.github_token)
-        print("GitHubRepoInfo initialized.")
-
-
-        self.neo4j_driver = None
-        # Check if Neo4j library was imported
-        if GraphDatabase and basic_auth and all([self.neo4j_uri, self.neo4j_user, self.neo4j_password]):
-            try:
-                print(f"Attempting to connect to Neo4j at {self.neo4j_uri}...")
-                # 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
-        else:
-            if not (GraphDatabase and basic_auth):
-                 print("Neo4j library not installed. Graph features disabled.")
-            else:
-                 print("Warning: Neo4j credentials not fully provided or library missing. Graph features will be disabled.")
-
-
+        
+        # Initialize Gemini model if API key is provided
         self.gemini_model = None
-        # Check if Gemini library was imported
-        if genai and self.gemini_api_key:
+        if self.gemini_api_key and GEMINI_AVAILABLE:
             try:
-                print("Configuring Google Generative AI...")
                 genai.configure(api_key=self.gemini_api_key)
-                # Use a known stable model, check Gemini docs for latest recommended models
-                # 'gemini-1.5-flash-latest' is often a good balance
-                # model_name = 'gemini-1.5-flash-latest'
-                # Let's stick to the user's specified model if possible, fallback otherwise
-                model_name = 'gemini-1.5-pro-latest' # User's original choice in one definition
-                # Check if the model exists (basic check)
-                # available_models = [m.name for m in genai.list_models() if 'generateContent' in m.supported_generation_methods]
-                # if model_name not in available_models:
-                #     print(f"Warning: Model '{model_name}' not found or doesn't support generateContent. Trying 'gemini-1.5-flash-latest'.")
-                #     model_name = 'gemini-1.5-flash-latest'
-                #     if model_name not in available_models:
-                #          print("Error: Could not find a suitable Gemini model.")
-                #          raise ValueError("No suitable Gemini model found.")
-
-                print(f"Initializing Gemini model: {model_name}")
-                self.gemini_model = genai.GenerativeModel(model_name)
-                # Test call (optional, might consume quota)
-                # self.gemini_model.generate_content("Test")
-                print("Gemini model initialized.")
+                self.gemini_model = genai.GenerativeModel('gemini-1.5-pro-latest')
+                print("Gemini model initialized for PR summarization.")
             except Exception as e:
                 print(f"Error initializing Gemini: {e}")
-                self.gemini_model = None
-        else:
-            if not genai:
-                print("Google Generative AI library not installed. Gemini features disabled.")
-            else:
-                print("Warning: Google API Key not provided or library missing. Gemini features will be disabled.")
-
-
-        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
-
-    # ... (rest of GraphRepoAnalyzer methods, ensure self.repo_data is checked before use) ...
-
-    # --- analyze_repo: Ensure it handles None return from get_all_info ---
-    def analyze_repo(self, owner, repo, display=True, save_json=False, export_text=False):
-        """Fetch, analyze, display, and optionally populate graph."""
-        # Validate inputs
-        if not owner or not isinstance(owner, str):
-             print("Error: Repository owner must be provided as a string.")
-             self.repo_data = None
-             return # Stop processing
-        if not repo or not isinstance(repo, str):
-             print("Error: Repository name must be provided as a string.")
-             self.repo_data = None
-             return # Stop processing
-
-        self.owner = owner.strip()
-        self.repo = repo.strip()
-        self.repo_full_name = f"{self.owner}/{self.repo}"
-        print(f"\n--- Starting Analysis for {self.repo_full_name} ---")
-
-        # Reset previous data
+        
         self.repo_data = None
+        self.owner = None
+        self.repo = None
+        self.repo_full_name = None
+
+    def analyze_repo(self, owner, repo):
+        """Analyze a GitHub repository and store the data."""
+        self.owner = owner
+        self.repo = repo
+        self.repo_full_name = f"{owner}/{repo}"
+        
+        print(f"\nFetching repository information for {self.repo_full_name}...")
+        self.repo_data = self.github_analyzer.get_all_info(owner, repo)
+        
+        if not self.repo_data:
+            print(f"Failed to get repository information for {self.repo_full_name}")
+            return False
+        
+        print(f"Successfully analyzed repository: {self.repo_full_name}")
+        return True
+    
+    def _get_pr_summary_prompt(self, pr_details, role):
+        """Generate a prompt for Gemini to summarize PR 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.
+"""
 
-        # Use the github_analyzer instance associated with this GraphRepoAnalyzer
-        if not self.github_analyzer:
-            print("Error: GitHubRepoInfo analyzer not initialized.")
-            return
-
-        try:
-            self.repo_data = self.github_analyzer.get_all_info(self.owner, self.repo)
-        except Exception as e:
-            print(f"An unexpected error occurred during get_all_info: {e}")
-            import traceback
-            traceback.print_exc() # Print stack trace for debugging
-            self.repo_data = None # Ensure repo_data is None on error
-
-        # Check if analysis succeeded and returned data
-        if self.repo_data and isinstance(self.repo_data, dict) and "basic_info" in self.repo_data:
-            print(f"--- Analysis Complete for {self.repo_full_name} ---")
-            # Proceed with display, save, export, populate etc.
-            if display and IPYTHON_AVAILABLE: # Only display if in IPython environment
-                print("\nGenerating visualizations and analysis (requires IPython environment)...")
-                try:
-                    # Wrap display calls in try/except as they can fail with odd data
-                    self.github_analyzer.display_repo_info(self.repo_data)
-                    self.github_analyzer.display_code_files(self.repo_data) # Show code preview
-                except Exception as display_error:
-                     print(f"Error during display generation: {display_error}")
-            elif display and not IPYTHON_AVAILABLE:
-                 print("\nSkipping visualizations: Not in an IPython environment (like Colab or Jupyter).")
-
-
-            if self.neo4j_driver:
-                try:
-                    # Use Gradio input later, for script execution use environment variable or fixed logic
-                    populate_graph = os.getenv("POPULATE_NEO4J", "false").lower() == 'true'
-                    # populate = input("\nPopulate Neo4j graph with this data? (y/n): ").lower() == 'y'
-                    if populate_graph:
-                        print("\nAttempting to populate Neo4j graph...")
-                        self.populate_neo4j_graph()
-                    else:
-                        print("\nSkipping Neo4j population.")
-                except Exception as neo4j_error:
-                     print(f"Error during Neo4j interaction prompt or population: {neo4j_error}")
-
-
-            if save_json:
-                 # Use fixed path or environment variable for non-interactive saving
-                 default_filename = f'./{self.repo}_info.json'
-                 filename = os.getenv("JSON_OUTPUT_PATH", default_filename)
-                 # filename = input(f"Enter filename for JSON output (default: {default_filename}): ") or default_filename
-                 print(f"\nSaving analysis results to JSON: {filename}")
-                 save_json_to_colab(self.repo_data, filename) # Use the enhanced save function
-
-            if export_text:
-                 # Use fixed path or environment variable for non-interactive saving
-                 default_dir = f'./{self.repo}_text'
-                 output_dir = os.getenv("TEXT_EXPORT_DIR", default_dir)
-                 # output_dir = input(f"Enter output directory for text export (default: {default_dir}): ") or default_dir
-                 print(f"\nExporting text content to directory: {output_dir}")
-                 self.github_analyzer.export_repo_text(self.repo_data, output_dir)
-
-        else:
-            # This case handles where get_all_info returned None or an invalid structure
-            print(f"--- Failed to get complete repository information for {self.repo_full_name} ---")
-            # self.repo_data is already None or invalid
-
+        return base_prompt + role_instructions + "\n**Summary:**"
 
-    # --- summarize_pull_request: Add checks ---
-    def summarize_pull_request(self, pr_number_str, role):
-        """Fetches PR details and generates a role-based summary using Gemini."""
+    def summarize_pull_request(self, pr_number, role='Developer'):
+        """Summarize a pull request using Gemini AI."""
         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 or provide them."
-        if not self.github_analyzer:
-             return "GitHub Analyzer not initialized."
-
-        # Validate PR number
-        try:
-            pr_number = int(pr_number_str)
-        except (ValueError, TypeError):
-             return f"Invalid Pull Request number: '{pr_number_str}'. Please provide an integer."
-
-        # Validate Role
-        valid_roles = ["Developer", "Manager", "Team Lead", "Product Owner", "Program Manager", "General"]
-        if role not in valid_roles:
-             return f"Invalid role: '{role}'. Please choose from: {', '.join(valid_roles)}"
-
+             return "Repository owner and name not set. Analyze a repository first."
 
         print(f"\nFetching details for PR #{pr_number} in {self.repo_full_name}...")
-        # get_pull_request_details handles its own errors and returns None on failure
         pr_details = self.github_analyzer.get_pull_request_details(self.owner, self.repo, pr_number)
 
         if not pr_details:
-            # Error message was already printed by get_pull_request_details
-            return f"Could not retrieve details for PR #{pr_number}. See previous error messages."
+            return f"Could not retrieve details for PR #{pr_number}."
 
         print(f"Generating summary for role: {role}...")
 
         # Generate the role-specific prompt
-        try:
-            prompt = self._get_pr_summary_prompt(pr_details, role)
-        except Exception as e:
-            print(f"Error generating Gemini prompt: {e}")
-            return "Error preparing the summary request."
+        prompt = self._get_pr_summary_prompt(pr_details, role)
 
-        # 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("-----------------------------")
-
-            # Use safety_settings to reduce refusals for code-related content if needed
-            # 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"},
-            # ]
-            # response = self.gemini_model.generate_content(prompt, safety_settings=safety_settings)
             response = self.gemini_model.generate_content(prompt)
-
-
-            # Check for empty or blocked response
-            if not response.parts:
-                 # Check prompt feedback for blockage reason
-                 block_reason = response.prompt_feedback.block_reason if response.prompt_feedback else "Unknown"
-                 print(f"Warning: Gemini response was empty or blocked. Reason: {block_reason}")
-                 return f"Summary generation failed. The request may have been blocked (Reason: {block_reason})."
-
             summary_text = response.text
-
-            print("\n--- Gemini PR Summary ---")
-            # Don't use display(Markdown()) here as it might not work outside notebooks
-            # Return the raw text for Gradio Markdown component
-            print(summary_text) # Print to console as well
-            print("------------------------")
-            return summary_text # Return raw text
-
+            return summary_text
         except Exception as e:
             print(f"Error communicating with Gemini for PR summary: {e}")
-            return f"Error asking Gemini: {e}"
+            return f"Error generating PR summary: {e}"
 
+    def create_dependency_network_html(self, output_file="dependency_network.html"):
+        """Create an interactive network visualization of dependencies using PyVis."""
+        if not self.repo_data:
+            print("No repository data available.")
+            return None
+            
+        # Get the dependencies
+        dependencies = self.repo_data.get("text_content", {}).get("dependencies", {})
+        if not dependencies:
+            print("No dependency data available.")
+            return None
+            
+        internal_deps = dependencies.get('internal', {})
+        external_deps = dependencies.get('external', {})
+        
+        # Create NetworkX graph first
+        G = nx.DiGraph()
+        
+        # Add file nodes and internal dependencies
+        for file_path, deps in internal_deps.items():
+            file_name = os.path.basename(file_path)
+            G.add_node(file_path, label=file_name, title=file_path, group="file")
+            
+            for dep in deps:
+                dep_name = os.path.basename(dep)
+                G.add_node(dep, label=dep_name, title=dep, group="file")
+                G.add_edge(file_path, dep)
+        
+        # Add external dependencies
+        for file_path, deps in external_deps.items():
+            if file_path not in G.nodes:
+                file_name = os.path.basename(file_path)
+                G.add_node(file_path, label=file_name, title=file_path, group="file")
+                
+            for dep in deps:
+                ext_node = f"ext:{dep}"
+                G.add_node(ext_node, label=dep, title=dep, group="external")
+                G.add_edge(file_path, ext_node)
+        
+        # Create PyVis network from NetworkX graph
+        net = Network(height="750px", width="100%", directed=True, notebook=False)
+        
+        # Set network options for better visualization
+        net.set_options("""
+        {
+            "physics": {
+                "hierarchicalRepulsion": {
+                    "centralGravity": 0.0,
+                    "springLength": 100,
+                    "springConstant": 0.01,
+                    "nodeDistance": 120
+                },
+                "maxVelocity": 50,
+                "minVelocity": 0.1,
+                "solver": "hierarchicalRepulsion"
+            },
+            "layout": {
+                "improvedLayout": true
+            }
+        }
+        """)
+        
+        # Add nodes with properties from NetworkX graph
+        for node, node_attrs in G.nodes(data=True):
+            group = node_attrs.get('group', 'file')
+            
+            # Set colors based on node type
+            color = "#97c2fc" if group == "file" else "#fb7e81"  # blue for files, red for external
+            
+            net.add_node(
+                node, 
+                label=node_attrs.get('label', str(node)),
+                title=node_attrs.get('title', str(node)),
+                color=color
+            )
+        
+        # Add edges
+        for source, target in G.edges():
+            net.add_edge(source, target)
+        
+        # Generate and save the HTML file
+        net.save_graph(output_file)
+        print(f"Dependency network visualization saved to {output_file}")
+        return output_file
 
-    # --- create_vizro_dashboard: Add robust data checks ---
     def create_vizro_dashboard(self, output_dir='./vizro_dashboard'):
         """Create a Vizro dashboard from repository data."""
-        # Check if Vizro is installed
-        if not vzm or not px or not go:
-             print("Vizro/Plotly not installed. Cannot create dashboard.")
-             return None
-
-        # Check if data exists and is minimally valid
-        if not self.repo_data or not isinstance(self.repo_data, dict) or not self.repo_data.get("basic_info"):
-            print("No valid repository data available. Run analyze_repo() first.")
+        if not self.repo_data:
+            print("No repository data available. Run analyze_repo() first.")
             return None
-
-        print("Creating Vizro dashboard...")
-
+            
         # Create output directory if it doesn't exist
-        try:
-             if not os.path.exists(output_dir):
-                 os.makedirs(output_dir)
-        except OSError as e:
-             print(f"Error creating output directory {output_dir}: {e}")
-             return None # Cannot proceed without output dir
-
-        # --- Safely Extract Data ---
-        basic_info = self.repo_data.get("basic_info", {}) # Default to empty dict
-        repo_name = basic_info.get("full_name", "Unknown Repo")
-        languages_data = self.repo_data.get("languages") # Can be None or {}
-        contributors_data = self.repo_data.get("contributors") # Can be None or []
-        temporal_analysis = self.repo_data.get("temporal_analysis", {}) # Default to {}
-        text_content = self.repo_data.get("text_content", {}) # Default to {}
-        dependencies_data = text_content.get("dependencies", {}) # Default to {}
-        complexity_metrics = text_content.get("complexity_metrics", {}) # Default to {}
-
-        # --- Create dashboard pages ---
+        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 = []
-        all_components = {} # Store components to avoid duplicates if needed
-
-        # --- 1. Overview Page ---
-        print("Building Overview Page...")
+        
+        # 1. Overview Page
         overview_components = []
-        try:
-            # Basic repository info card - use .get for safety
-            repo_info_md = f"""
-            # {basic_info.get('full_name', 'N/A')}
-
-            **Description:** {basic_info.get('description', 'No description')}
-
-            **Stars:** {basic_info.get('stargazers_count', 'N/A')} |
-            **Forks:** {basic_info.get('forks_count', 'N/A')} |
-            **Open Issues:** {basic_info.get('open_issues_count', 'N/A')}
-
-            **Created:** {basic_info.get('created_at', 'N/A')} |
-            **Last Updated:** {basic_info.get('updated_at', 'N/A')}
-
-            **Default Branch:** {basic_info.get('default_branch', 'N/A')}
-
-            **License:** {basic_info.get('license', {}).get('name', 'Not specified')}
-            """ # Safe access for license
-
-            overview_components.append(vzm.Card(text=repo_info_md, title="Repository Info"))
-            all_components['repo_info_card'] = overview_components[-1]
-
-
-            # Languages pie chart
-            if isinstance(languages_data, dict) and languages_data:
-                langs_prep_data = []
-                total_bytes = sum(v for v in languages_data.values() if isinstance(v, (int, float)))
-                if total_bytes > 0:
-                    for lang, bytes_count in languages_data.items():
-                        if isinstance(bytes_count, (int, float)) and bytes_count > 0:
-                             percentage = (bytes_count / total_bytes) * 100
-                             langs_prep_data.append({
-                                 "Language": str(lang), # Ensure string
-                                 "Bytes": bytes_count,
-                                 "Percentage": percentage
-                             })
-
-                    if langs_prep_data: # Check if we have data to plot
-                        langs_df = pd.DataFrame(langs_prep_data)
-                        lang_pie_fig = px.pie(
-                            langs_df,
-                            values="Percentage",
-                            names="Language",
-                            title="Language Distribution"
-                        )
-                        lang_pie = vzm.Graph(figure=lang_pie_fig)
-                        overview_components.append(vzm.Card(children=[lang_pie])) # Wrap graph in children list
-                        all_components['lang_pie'] = overview_components[-1]
-                    else:
-                        print("No valid language data to plot.")
-                else:
-                     print("Language data present but total bytes are zero or invalid.")
-            else:
-                 print("No language data found or data is not a dictionary.")
-
-
-            # Contributors bar chart
-            if isinstance(contributors_data, list) and contributors_data:
-                contrib_prep_data = []
-                for contributor in contributors_data[:15]: # Limit display
-                     if isinstance(contributor, dict) and 'login' in contributor and 'contributions' in contributor:
-                         contrib_prep_data.append({
-                             "Username": str(contributor['login']), # Ensure string
-                             "Contributions": int(contributor['contributions']) # Ensure int
-                         })
-
-                if contrib_prep_data: # Check if data to plot
-                     contrib_df = pd.DataFrame(contrib_prep_data)
-                     contrib_bar_fig = px.bar(
-                         contrib_df,
-                         x="Username",
-                         y="Contributions",
-                         title="Top Contributors"
-                     )
-                     contrib_bar = vzm.Graph(figure=contrib_bar_fig)
-                     overview_components.append(vzm.Card(children=[contrib_bar])) # Wrap graph in children list
-                     all_components['contrib_bar'] = overview_components[-1]
-                else:
-                     print("No valid contributor data to plot.")
-            else:
-                 print("No contributor data found or data is not a list.")
-
-            # Add overview page if components exist
-            if overview_components:
-                 pages.append(
-                     vzm.Page(
-                         title="Overview",
-                         components=overview_components,
-                         path="overview" # Add unique path
-                     )
-                 )
-            else:
-                 print("Skipping Overview page: No components generated.")
-
-        except Exception as e:
-             print(f"Error building Overview page: {e}")
-             # Optionally add an error card to the dashboard
-             # overview_components.append(vzm.Card(text=f"Error building overview: {e}"))
-
-
-        # --- 2. Activity Page ---
-        print("Building Activity Page...")
+        
+        # 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
+            )
+        )
+        
+        # 2. Activity Page
         activity_components = []
-        try:
-            # Commit activity over time
-            weekly_commits = temporal_analysis.get("weekly_commits", [])
-            if isinstance(weekly_commits, list) and weekly_commits:
-                commits_prep_data = []
-                for week in weekly_commits:
-                    if isinstance(week, dict) and 'date' in week and 'total' in week:
-                        try:
-                            # Validate date and convert total to int
-                            date_val = pd.to_datetime(week['date'])
-                            commits_val = int(week['total'])
-                            commits_prep_data.append({"Date": date_val, "Commits": commits_val})
-                        except (ValueError, TypeError):
-                            continue # Skip invalid entries
-
-                if commits_prep_data:
-                    commits_df = pd.DataFrame(commits_prep_data)
-                    if not commits_df.empty:
-                         commits_line_fig = px.line(
-                             commits_df,
-                             x="Date",
-                             y="Commits",
-                             title="Weekly Commit Activity"
-                         )
-                         commits_line = vzm.Graph(figure=commits_line_fig)
-                         activity_components.append(vzm.Card(children=[commits_line]))
-                         all_components['commits_line'] = activity_components[-1]
-                else:
-                    print("No valid commit data to plot.")
-            else:
-                 print("No weekly commit data found or data is not a list.")
-
-
-            # Code changes over time
-            weekly_code_changes = temporal_analysis.get("weekly_code_changes", [])
-            if isinstance(weekly_code_changes, list) and weekly_code_changes:
-                changes_prep_data = []
-                for week in weekly_code_changes:
-                    if isinstance(week, dict) and 'date' in week and 'additions' in week and 'deletions' in week:
-                         try:
-                             date_val = pd.to_datetime(week['date'])
-                             additions_val = int(week['additions'])
-                             deletions_val = int(week['deletions'])
-                             changes_prep_data.append({
-                                 "Date": date_val,
-                                 "Additions": additions_val,
-                                 "Deletions": -abs(deletions_val)  # Make negative for relative bar chart
-                             })
-                         except (ValueError, TypeError):
-                             continue # Skip invalid entries
-
-                if changes_prep_data:
-                    changes_df = pd.DataFrame(changes_prep_data)
-                    if not changes_df.empty:
-                        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", xaxis_title="Date", yaxis_title="Lines Changed")
-                        changes_chart = vzm.Graph(figure=changes_fig)
-                        activity_components.append(vzm.Card(children=[changes_chart]))
-                        all_components['changes_chart'] = activity_components[-1]
-                else:
-                    print("No valid code change data to plot.")
-            else:
-                 print("No weekly code change data found or data is not a list.")
-
-            # Issue resolution times
-            issue_timeline = temporal_analysis.get("issue_timeline", {})
-            if isinstance(issue_timeline, dict):
-                 resolution_times = issue_timeline.get('resolution_times', [])
-                 if isinstance(resolution_times, list) and resolution_times:
-                     # Convert to hours safely, cap at one week (168 hours)
-                     rt_hours = []
-                     for rt in resolution_times:
-                         if isinstance(rt, (int, float)) and rt >= 0:
-                              rt_hours.append(min(rt, 168))
-
-                     if rt_hours: # Check if we have valid data after cleaning
-                         rt_hours_array = np.array(rt_hours) # For numpy functions
-                         issue_resolution_fig = px.histogram(
-                             x=rt_hours_array,
-                             title="Issue Resolution Times (Capped at 1 Week)",
-                             labels={"x": "Hours to Resolution"}
-                         )
-                         mean_rt = np.mean(rt_hours_array)
-                         median_rt = np.median(rt_hours_array)
-                         issue_resolution_fig.add_vline(x=mean_rt, line_dash="dash", line_color="red", annotation_text=f"Mean: {mean_rt:.2f} hrs")
-                         issue_resolution_fig.add_vline(x=median_rt, line_dash="dash", line_color="green", annotation_text=f"Median: {median_rt:.2f} hrs")
-
-                         resolution_hist = vzm.Graph(figure=issue_resolution_fig)
-                         activity_components.append(vzm.Card(children=[resolution_hist]))
-                         all_components['issue_res_hist'] = activity_components[-1]
-                     else:
-                         print("No valid numeric issue resolution times found.")
-                 else:
-                     print("No issue resolution times found or data is not a list.")
-            else:
-                 print("Issue timeline data is not a dictionary.")
-
-            # Add activity page if components exist
-            if activity_components:
-                 pages.append(
-                     vzm.Page(
-                         title="Activity",
-                         components=activity_components,
-                         path="activity" # Add unique path
-                     )
-                 )
-            else:
-                 print("Skipping Activity page: No components generated.")
-
-        except Exception as e:
-             print(f"Error building Activity page: {e}")
-
-
-        # --- 3. Code Quality Page ---
-        print("Building Code Quality Page...")
+        
+        # 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 = []
-        try:
-            # Code complexity metrics
-            cyclomatic_complexity = complexity_metrics.get("cyclomatic_complexity", [])
-            if isinstance(cyclomatic_complexity, list) and cyclomatic_complexity:
-                 complexity_prep_data = []
-                 for item in cyclomatic_complexity:
-                     if isinstance(item, (list, tuple)) and len(item) == 2:
-                         path, cc = item
-                         if isinstance(path, str) and isinstance(cc, (int, float)):
-                             complexity_prep_data.append({
-                                 "File": os.path.basename(path),
-                                 "Path": path,
-                                 "Complexity": cc
-                             })
-
-                 if complexity_prep_data:
-                     complexity_prep_data.sort(key=lambda x: x["Complexity"], reverse=True)
-                     top_complex_files = complexity_prep_data[:15] # Show top 15
-                     complex_df = pd.DataFrame(top_complex_files)
-
-                     if not complex_df.empty:
-                         complex_bar_fig = px.bar(
-                             complex_df, x="File", y="Complexity", title="Most Complex Files (Top 15)", hover_data=["Path"]
-                         )
-                         complex_bar = vzm.Graph(figure=complex_bar_fig)
-                         code_components.append(vzm.Card(children=[complex_bar]))
-                         all_components['complex_bar'] = code_components[-1]
-
-                         # Complexity histogram (using all valid data)
-                         cc_values = [d["Complexity"] for d in complexity_prep_data]
-                         if cc_values:
-                             cc_hist_fig = px.histogram(
-                                 x=cc_values, title="Cyclomatic Complexity Distribution", labels={"x": "Complexity"}
-                             )
-                             cc_hist = vzm.Graph(figure=cc_hist_fig)
-                             code_components.append(vzm.Card(children=[cc_hist]))
-                             all_components['cc_hist'] = code_components[-1]
-                 else:
-                     print("No valid cyclomatic complexity data found.")
-            else:
-                print("No cyclomatic complexity data found or data is not a list.")
-
-
-            # Comment ratio by file
-            comment_ratios = complexity_metrics.get("comment_ratios", [])
-            if isinstance(comment_ratios, list) and comment_ratios:
-                 comment_prep_data = []
-                 for item in comment_ratios:
-                     if isinstance(item, (list, tuple)) and len(item) == 2:
-                         path, ratio = item
-                         if isinstance(path, str) and isinstance(ratio, (int, float)) and ratio >= 0:
-                             comment_prep_data.append({
-                                 "File": os.path.basename(path),
-                                 "Path": path,
-                                 "Comment Ratio": ratio
-                             })
-
-                 if comment_prep_data:
-                     comment_prep_data.sort(key=lambda x: x["Comment Ratio"], reverse=True)
-                     top_commented_files = comment_prep_data[:15] # Show top 15
-                     comment_df = pd.DataFrame(top_commented_files)
-
-                     if not comment_df.empty:
-                        comment_bar_fig = px.bar(
-                            comment_df, x="File", y="Comment Ratio", title="Files with Highest Comment Ratio (Top 15)", hover_data=["Path"]
-                        )
-                        comment_bar = vzm.Graph(figure=comment_bar_fig)
-                        code_components.append(vzm.Card(children=[comment_bar]))
-                        all_components['comment_bar'] = code_components[-1]
-                 else:
-                    print("No valid comment ratio data found.")
-            else:
-                 print("No comment ratio data found or data is not a list.")
-
-            # Add code quality page if components exist
-            if code_components:
-                pages.append(
-                    vzm.Page(
-                        title="Code Quality",
-                        components=code_components,
-                        path="code_quality" # Add unique path
+        
+        # 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"]
                     )
                 )
-            else:
-                print("Skipping Code Quality page: No components generated.")
-
-        except Exception as e:
-             print(f"Error building Code Quality page: {e}")
-
-
-        # --- 4. Dependencies Page ---
-        print("Building Dependencies Page...")
-        dependencies_components = []
-        try:
+                
+                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_data.get("external", {})
-            if isinstance(external_deps, dict) and external_deps:
+            external_deps = dependencies.get("external", {})
+            if external_deps:
+                # Count packages
                 ext_counts = Counter()
-                for file_path, deps_set in external_deps.items():
-                    if isinstance(deps_set, (set, list)): # Handle set or list
-                        for dep in deps_set:
-                            if isinstance(dep, str): # Ensure dep is string
-                                ext_counts[dep] += 1
-
-                if ext_counts:
-                    top_deps = ext_counts.most_common(15) # Show top 15
-                    deps_prep_data = [{"Package": pkg, "Count": count} for pkg, count in top_deps]
-                    deps_df = pd.DataFrame(deps_prep_data)
-
-                    if not deps_df.empty:
-                        deps_bar_fig = px.bar(
-                            deps_df, x="Package", y="Count", title="Most Used External Dependencies (Top 15)"
-                        )
-                        deps_bar = vzm.Graph(figure=deps_bar_fig)
-                        dependencies_components.append(vzm.Card(children=[deps_bar]))
-                        all_components['deps_bar'] = dependencies_components[-1]
-                else:
-                    print("No external dependency data counted.")
-            else:
-                 print("No external dependency data found or data is not a dictionary.")
-
-
-            # Internal dependencies graph (only for smaller graphs)
-            internal_deps = dependencies_data.get("internal", {})
-            if isinstance(internal_deps, dict) and internal_deps:
-                 num_nodes_internal = len(set(internal_deps.keys()) | set(d for deps in internal_deps.values() for d in deps))
-                 if num_nodes_internal <= 75:  # Increased limit slightly
-                     print(f"Attempting internal dependency graph ({num_nodes_internal} nodes)...")
-                     try:
-                         # Create NetworkX graph
-                         G = nx.DiGraph()
-                         nodes_added = set()
-
-                         for source, targets in internal_deps.items():
-                             if isinstance(source, str):
-                                 source_name = os.path.basename(source)
-                                 if source not in nodes_added:
-                                     G.add_node(source, name=source_name)
-                                     nodes_added.add(source)
-
-                                 if isinstance(targets, (set, list)):
-                                     for target in targets:
-                                         if isinstance(target, str):
-                                             target_name = os.path.basename(target)
-                                             if target not in nodes_added:
-                                                 G.add_node(target, name=target_name)
-                                                 nodes_added.add(target)
-                                             # Add edge only if both nodes were added successfully
-                                             if source in G and target in G:
-                                                  G.add_edge(source, target)
-
-                         if G.number_of_nodes() > 0 and G.number_of_edges() > 0:
-                             # Get position layout
-                             pos = nx.spring_layout(G, seed=42, k=0.6, iterations=50) # Adjust layout params
-
-                             # 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, node_color_val = [], [], [], []
-                             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))
-                                 degree = G.degree(node) # Use degree for size/color
-                                 node_color_val.append(degree)
-
-
-                             node_trace = go.Scatter(
-                                 x=node_x, y=node_y, mode='markers+text', hoverinfo='text', text=node_text,
-                                 textposition="top center", textfont=dict(size=8, color='black'),
-                                 marker=dict(showscale=True, colorscale='YlGnBu', size=10, color=node_color_val,
-                                             colorbar=dict(thickness=15, title='Node Degree', xanchor='left', titleside='right'))
-                             )
-
-                             dep_fig = go.Figure(data=[edge_trace, node_trace],
-                                                 layout=go.Layout(
-                                                     title='Internal File Dependency Network (Nodes <= 75)', 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))
-                                                )
-
-                             dep_graph_viz = vzm.Graph(figure=dep_fig)
-                             dependencies_components.append(vzm.Card(children=[dep_graph_viz]))
-                             all_components['dep_graph'] = dependencies_components[-1]
-                         else:
-                              print("Internal dependency graph has no nodes or edges after processing.")
-
-                     except Exception as e_graph:
-                         print(f"Error generating internal dependency network visualization: {e_graph}")
-                 else:
-                     print(f"Skipping internal dependency graph: Too large ({num_nodes_internal} nodes).")
-            else:
-                 print("No internal dependency data found or data is not a dictionary.")
-
-
-            # Add dependencies page if components exist
+                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))
+            
+            # Create dependency network visualization with PyVis in a separate HTML file
+            # and embed a note about it in the dashboard
+            try:
+                network_file = self.create_dependency_network_html(
+                    output_file=os.path.join(output_dir, "dependency_network.html")
+                )
+                
+                if network_file:
+                    network_note = f"""
+                    ## Code Dependency Network
+                    
+                    An interactive visualization of code dependencies has been created as a separate file:
+                    `{os.path.basename(network_file)}`
+                    
+                    Open this file in a web browser to explore the code dependency network.
+                    """
+                    
+                    dependencies_components.append(vzm.Card(text=network_note))
+            except Exception as e:
+                print(f"Error creating dependency network: {e}")
+            
+            # Add dependencies page if we have components
             if dependencies_components:
                 pages.append(
                     vzm.Page(
                         title="Dependencies",
-                        components=dependencies_components,
-                        path="dependencies" # Add unique path
+                        components=dependencies_components
                     )
                 )
-            else:
-                 print("Skipping Dependencies page: No components generated.")
-
-        except Exception as e:
-             print(f"Error building Dependencies page: {e}")
-
-
-        # --- Create the dashboard ---
-        if not pages:
-             print("No pages were generated for the dashboard. Cannot create dashboard.")
-             return None
-
+        
+        # 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")
         try:
-            # Define navigation if multiple pages exist
-            navigation = None
-            if len(pages) > 1:
-                 navigation=vzm.Navigation(pages=[p.title for p in pages]) # Use titles for navigation links
-
-            dashboard = vzm.Dashboard(
-                title=f"GitHub Analysis: {repo_name}",
-                pages=pages,
-                navigation=navigation
-            )
-
-            # Export dashboard (using save method which implicitly builds and exports)
-            # dashboard_path = os.path.join(output_dir, "dashboard.html")
-            # dashboard.save(dashboard_path) # build() is deprecated, save() does it
-            # Build dashboard (required before getting HTML string or running)
-            print("Building dashboard...")
-            vizro.build(dashboard)
-            print("Dashboard built.")
-
-            # We don't save to file here, Gradio will handle serving if we run it
-            # Instead of returning path, maybe return the dashboard object or indicate success
-            return dashboard # Return the dashboard object for potential further use
-
+            dashboard.save(dashboard_path)
+            print(f"Vizro dashboard saved to {dashboard_path}")
+            return dashboard_path
         except Exception as e:
-            print(f"Error creating or building Vizro dashboard object: {e}")
-            import traceback
-            traceback.print_exc()
+            print(f"Error saving dashboard: {e}")
             return None
 
 
-# --- Gradio Interface ---
+# Create Gradio interface
 def create_gradio_interface():
     """Create a Gradio interface for the GitHub repository analyzer."""
-    if not gr:
-         print("Gradio library not found. Cannot create interface.")
-         return None
-
-    # Shared state to store the analyzer instance
-    analyzer_instance = None
-
-    def analyze_repository_gradio(owner, repo, github_token=None, neo4j_uri=None, neo4j_user=None, neo4j_password=None, gemini_api_key=None):
-        """Gradio callback function to analyze a repository."""
-        nonlocal analyzer_instance
-        print(f"\n--- Gradio: analyze_repository_gradio called for {owner}/{repo} ---")
-        report = f"Starting analysis for {owner}/{repo}...\n"
-        dashboard_html_content = "" # Default empty dashboard
-
+    
+    def analyze_repository(owner, repo, github_token=None, gemini_api_key=None):
+        """Function to analyze a repository and return a Vizro dashboard."""
         try:
-            # Ensure owner and repo are provided
-            if not owner or not repo:
-                report += "\nError: Please provide both Repository Owner and Name."
-                return report, dashboard_html_content # Return report and empty dashboard HTML
-
-            # Instantiate the analyzer (or reuse if desired, but new instance is safer for credentials)
-            # Pass credentials safely, using None if empty string
-            analyzer_instance = GraphRepoAnalyzer(
+            analyzer = RepoAnalyzer(
                 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
             )
-            report += f"Analyzer initialized for {owner}/{repo}.\n"
-            yield report, dashboard_html_content # Update Gradio UI
-
-            # Analyze repository (this prints logs to console)
-            # Set display=False as we handle output via Gradio components
-            # Set save/export to False unless specifically controlled via UI
-            analyzer_instance.analyze_repo(owner, repo, display=False, save_json=False, export_text=False)
-
-            # Check if analysis was successful
-            if not analyzer_instance.repo_data:
-                report += f"\nError: Failed to analyze repository: {owner}/{repo}. Check console logs for details (e.g., invalid name, token issues, rate limits)."
-                # analyzer_instance remains None or has no data
-                return report, dashboard_html_content # Return error report
-
-            report += f"\nAnalysis complete for {analyzer_instance.repo_full_name}.\nGenerating dashboard and report...\n"
-            yield report, dashboard_html_content # Update UI
-
-            # --- Generate Report String ---
-            try:
-                 basic_info = analyzer_instance.repo_data.get("basic_info", {})
-                 report += f"""
-### Repository Analysis: {basic_info.get('full_name', 'N/A')}
+            
+            # Analyze repository
+            success = analyzer.analyze_repo(owner, repo)
+            
+            if not success:
+                return None, None, f"Failed to analyze repository: {owner}/{repo}. Check the repository name and your GitHub token."
+            
+            # Create Vizro dashboard
+            dashboard_path = analyzer.create_vizro_dashboard(output_dir='./vizro_dashboard')
+            
+            # Create dependency network visualization
+            network_path = analyzer.create_dependency_network_html(output_file='./vizro_dashboard/dependency_network.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.get('stargazers_count', 'N/A')}
-- Forks: {basic_info.get('forks_count', 'N/A')}
-- Open Issues: {basic_info.get('open_issues_count', 'N/A')}
-
-"""
-                 # Add language info safely
-                 languages = analyzer_instance.repo_data.get("languages")
-                 if isinstance(languages, dict) and languages:
-                     report += "**Language Summary:**\n"
-                     total = sum(v for v in languages.values() if isinstance(v, (int, float)))
-                     if total > 0:
-                         # Sort languages by percentage
-                         lang_items = []
-                         for lang, b_count in languages.items():
-                              if isinstance(b_count, (int, float)) and b_count > 0:
-                                  lang_items.append((lang, (b_count / total) * 100))
-                         # Sort descending by percentage
-                         lang_items.sort(key=lambda item: item[1], reverse=True)
-
-                         for lang, percentage in lang_items[:5]: # Show top 5
-                             report += f"- {lang}: {percentage:.1f}%\n"
-                         if len(lang_items) > 5:
-                              report += "- ... (other languages)\n"
-                     else:
-                         report += "- (No valid language byte counts found)\n"
-                 else:
-                     report += "**Language Summary:** Not available.\n"
-
-
-                 # Add code metrics if available
-                 text_content = analyzer_instance.repo_data.get("text_content", {})
-                 agg_metrics = text_content.get("aggregate_metrics")
-                 if isinstance(agg_metrics, dict):
-                     report += f"""
-**Code Metrics (Approximate):**
-- Text Files Analyzed: {agg_metrics.get('total_files_analyzed', 'N/A')}
-- Code Files Summarized: {agg_metrics.get('code_files_summarized', 'N/A')}
-- Total Code Lines: {agg_metrics.get('total_code_lines', 'N/A')}
-- Comment Ratio: {agg_metrics.get('average_comment_ratio', -1):.2f}
-"""                 # Use -1 or similar to indicate if ratio couldn't be calculated
-                 else:
-                     report += "\n**Code Metrics:** Not available.\n"
-
-            except Exception as report_err:
-                 print(f"Error generating report section: {report_err}")
-                 report += f"\nError generating parts of the report: {report_err}"
-
-
-            # --- Generate Dashboard ---
-            # Use a temporary directory for Gradio deployment
-            dashboard_dir = f"./gradio_dashboards/{owner}_{repo}"
-            dashboard_obj = analyzer_instance.create_vizro_dashboard(output_dir=dashboard_dir)
-
-            if dashboard_obj:
-                # Instead of saving, we want to serve it. Vizro doesn't directly give HTML string easily.
-                # Option 1: Save to file and load into IFrame (might have security issues / path issues)
-                # dashboard_path = os.path.join(dashboard_dir, 'dashboard.html') # create_vizro_dashboard doesn't save anymore
-                # vizro.run() # This blocks and runs a server - not ideal for embedding
-                # For Gradio, the best approach is often *not* to embed Vizro directly,
-                # but rather extract the Plotly figures and display them using gr.Plot.
-                # Let's try a simpler approach first: generate static plots for Gradio.
-
-                # --- Alternative: Generate static plots for Gradio ---
-                # This avoids Vizro complexity within Gradio's environment for now.
-                # We will just return the report. The dashboard creation is still useful if run standalone.
-                report += "\n\n**Dashboard Note:** Interactive dashboard generation logic exists but embedding Vizro directly in Gradio is complex. The dashboard can be generated by running the script standalone."
-                print("Dashboard object created, but not embedding in Gradio output for simplicity.")
-                # dashboard_html_content = f'<p>Vizro dashboard created but cannot be directly embedded here. Run script standalone.</p>'
-
-
-                # Option 2: If you *really* need to embed, save and use an iframe (less reliable)
-                # try:
-                #     dashboard_path_rel = os.path.join(dashboard_dir, 'dashboard.html')
-                #     dashboard_path_abs = os.path.abspath(dashboard_path_rel)
-                #     # Vizro's save method implicitly builds and saves
-                #     dashboard_obj.save(dashboard_path_abs)
-                #     print(f"Dashboard saved to: {dashboard_path_abs}")
-                #     # IMPORTANT: Gradio needs to be able to access this path.
-                #     # This might only work if Gradio serves from the same root or paths are configured.
-                #     # Use relative path for iframe src if possible, requires Gradio server setup.
-                #     # Using absolute file URI might work locally but not when deployed.
-                #     # dashboard_html_content = f'<iframe src="file:///{dashboard_path_abs}" width="100%" height="600px" style="border:none;"></iframe>'
-                #     # Safer: Provide a link
-                #     dashboard_html_content = f'<p>Dashboard saved to: <a href="file:///{dashboard_path_abs}" target="_blank">{dashboard_path_abs}</a> (Link may only work locally)</p>'
-                #     report += f"\n\n**Dashboard:** Saved locally. See link below (may only work on the server machine)."
-
-                # except Exception as vizro_save_err:
-                #      print(f"Error saving Vizro dashboard: {vizro_save_err}")
-                #      report += f"\n\n**Dashboard:** Error saving dashboard: {vizro_save_err}"
-                #      dashboard_html_content = f'<p>Error saving dashboard: {vizro_save_err}</p>'
-
-            else:
-                report += "\n\n**Dashboard:** Failed to generate dashboard object."
-                dashboard_html_content = "<p>Failed to generate dashboard.</p>"
+- 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}`
 
-            print("--- Gradio analysis function finished ---")
-            yield report, dashboard_html_content # Final update
+**Dependency Network:**
+The interactive dependency network visualization has been created at: `{network_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, network_path, report
+            
         except Exception as e:
-            print(f"--- Error in analyze_repository_gradio for {owner}/{repo} ---")
-            import traceback
-            traceback.print_exc()
-            report += f"\n\nCritical Error during analysis: {str(e)}"
-            # Ensure analyzer_instance is cleared if it failed early
-            analyzer_instance = None
-            # Return error report and empty dashboard
-            # Need yield here if using generator
-            yield report, dashboard_html_content
-
-
-    def summarize_pr_gradio(owner, repo, pr_number_str, role, github_token=None, gemini_api_key=None):
-        """Gradio callback function to summarize a PR."""
-        print(f"\n--- Gradio: summarize_pr_gradio called for PR #{pr_number_str} in {owner}/{repo} ---")
-        summary_output = "Starting PR summarization...\n"
-
+            return None, 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:
-            # Ensure owner, repo, pr_number, role, and gemini_key are provided
-            if not all([owner, repo, pr_number_str, role, gemini_api_key]):
-                 missing = [name for name, val in locals().items() if name in ['owner', 'repo', 'pr_number_str', 'role', 'gemini_api_key'] and not val]
-                 summary_output += f"Error: Please provide all required fields (Missing: {', '.join(missing)})."
-                 return summary_output
-
-            # --- Use a temporary analyzer instance for PR summary ---
-            # This avoids issues if the main analysis failed or used different credentials
-            # We only need GitHub and Gemini parts for this.
-            pr_analyzer = GraphRepoAnalyzer(
-                 github_token=github_token if github_token else None,
-                 gemini_api_key=gemini_api_key # Required
+            analyzer = RepoAnalyzer(
+                github_token=github_token if github_token else None,
+                gemini_api_key=gemini_api_key if gemini_api_key else None
             )
-
-            if not pr_analyzer.github_analyzer:
-                 summary_output += "Error: Could not initialize GitHub analyzer (check token/installation)."
-                 return summary_output
-            if not pr_analyzer.gemini_model:
-                 summary_output += "Error: Could not initialize Gemini model (check API key/installation)."
-                 return summary_output
-
-            # Set repo context for the analyzer
-            pr_analyzer.owner = owner
-            pr_analyzer.repo = repo
-            pr_analyzer.repo_full_name = f"{owner}/{repo}"
-
-            # Call the summarize_pull_request method (which now returns text)
-            summary = pr_analyzer.summarize_pull_request(pr_number_str, role) # Handles int conversion and validation internally
-
-            # summarize_pull_request returns the summary text or an error message
-            summary_output = summary # Assign the result directly
-
-            print("--- Gradio PR summary function finished ---")
-            return summary_output
-
+            
+            # Analyze repo first (lightweight)
+            success = analyzer.analyze_repo(owner, repo)
+            if not success:
+                return f"Failed to analyze repository: {owner}/{repo}. Check the repository name and your GitHub token."
+            
+            # Summarize the PR
+            summary = analyzer.summarize_pull_request(int(pr_number), role)
+            
+            return summary
+            
         except Exception as e:
-            print(f"--- Error in summarize_pr_gradio ---")
-            import traceback
-            traceback.print_exc()
-            summary_output += f"\n\nCritical Error during PR summarization: {str(e)}"
-            return summary_output
-
-
-    # --- Define Gradio UI ---
-    with gr.Blocks(title="GitHub Repository Analyzer", theme=gr.themes.Soft()) as app:
-        gr.Markdown("# GitHub Repository Analyzer & PR Summarizer")
-        gr.Markdown("Analyze GitHub repositories using GitHub API, generate reports, and summarize Pull Requests using Google Gemini.")
-
+            return f"Error summarizing PR: {str(e)}"
+    
+    def view_dashboard(dashboard_path):
+        """Load dashboard content for the iframe."""
+        try:
+            if not dashboard_path or not os.path.exists(dashboard_path):
+                return "Dashboard file not found"
+                
+            with open(dashboard_path, 'r', encoding='utf-8') as f:
+                html_content = f.read()
+                
+            return html_content
+        except Exception as e:
+            return f"Error loading dashboard: {str(e)}"
+    
+    def view_network(network_path):
+        """Load network visualization content for the iframe."""
+        try:
+            if not network_path or not os.path.exists(network_path):
+                return "Network visualization file not found"
+                
+            with open(network_path, 'r', encoding='utf-8') as f:
+                html_content = f.read()
+                
+            return html_content
+        except Exception as e:
+            return f"Error loading network visualization: {str(e)}"
+    
+    # UI Components
+    with gr.Blocks(title="GitHub Repository Analyzer") as app:
+        gr.Markdown("# GitHub Repository Analyzer with Vizro and PyVis")
+        gr.Markdown("Analyze GitHub repositories, visualize code dependencies, and summarize pull requests")
+        
         with gr.Tab("Repository Analysis"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### Repository Input")
-                    owner_input = gr.Textbox(label="Repository Owner", placeholder="e.g., 'google' or 'openai'")
-                    repo_input = gr.Textbox(label="Repository Name", placeholder="e.g., 'guetzli' or 'whisper'")
-
-                    gr.Markdown("### Credentials (Optional / Recommended)")
-                    github_token = gr.Textbox(label="GitHub Token", type="password", placeholder="Enter personal access token (optional, increases rate limit)")
-
-                    with gr.Accordion("Advanced Settings (Neo4j/Gemini - Optional for Analysis)", open=False):
-                        neo4j_uri = gr.Textbox(label="Neo4j URI", placeholder="bolt://localhost:7687")
-                        neo4j_user = gr.Textbox(label="Neo4j Username", placeholder="neo4j")
-                        neo4j_password = gr.Textbox(label="Neo4j Password", type="password")
-                        # Gemini key needed here if we add repo Q&A later
-                        # gemini_api_key_analysis = gr.Textbox(label="Google API Key (for Repo Q&A)", type="password", placeholder="Enter Google API Key (if using Repo Q&A)")
-
-                    analyze_btn = gr.Button("Analyze Repository", variant="primary")
-
+                    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")
+                    gemini_api_key = gr.Textbox(label="Google API Key (Optional, for PR Summaries)", type="password")
+                    
+                    analyze_btn = gr.Button("Analyze Repository")
+                
                 with gr.Column(scale=2):
-                    gr.Markdown("### Analysis Output")
-                    report_output = gr.Markdown(label="Analysis Report", value="Analysis results will appear here...")
-                    # Removed dashboard HTML output as direct embedding is unreliable
-                    # dashboard_output = gr.HTML(label="Dashboard Preview") # Keep if attempting iframe later
-
-            # Wire the button click event
+                    report_output = gr.Markdown(label="Analysis Report")
+            
+            # Store paths but don't display them
+            dashboard_path_state = gr.State()
+            network_path_state = gr.State()
+            
+            with gr.Tabs():
+                with gr.TabItem("Dashboard"):
+                    dashboard_frame = gr.HTML(label="Dashboard Preview", height=600)
+                
+                with gr.TabItem("Dependency Network"):
+                    network_frame = gr.HTML(label="Dependency Network", height=600)
+            
             analyze_btn.click(
-                analyze_repository_gradio,
+                analyze_repository,
                 inputs=[
-                    owner_input, repo_input, github_token,
-                    neo4j_uri, neo4j_user, neo4j_password,
-                    # gemini_api_key_analysis # Pass if adding Repo Q&A
+                    owner_input, repo_input, github_token, gemini_api_key
                 ],
-                # Output only the report for now
-                outputs=[report_output] # Removed dashboard_output
+                outputs=[dashboard_path_state, network_path_state, report_output]
             )
-
-        with gr.Tab("PR Summarizer (Requires Gemini)"):
+            
+            # Update iframes when paths change
+            dashboard_path_state.change(
+                view_dashboard,
+                inputs=[dashboard_path_state],
+                outputs=[dashboard_frame]
+            )
+            
+            network_path_state.change(
+                view_network,
+                inputs=[network_path_state],
+                outputs=[network_frame]
+            )
+        
+        with gr.Tab("PR Summarizer"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### PR Input")
-                    pr_owner_input = gr.Textbox(label="Repository Owner", placeholder="Owner of the repo containing the PR")
-                    pr_repo_input = gr.Textbox(label="Repository Name", placeholder="Name of the repo containing the PR")
-                    pr_number_input = gr.Textbox(label="PR Number", placeholder="e.g., 123") # Use Textbox for flexibility
+                    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 (Tailors Summary)",
-                        value="Developer" # Default value
+                        label="Your Role",
+                        value="Developer"
                     )
-
-                    gr.Markdown("### Credentials")
-                    pr_github_token = gr.Textbox(label="GitHub Token (Optional)", type="password", placeholder="Needed for private repos or high rate limits")
-                    pr_gemini_api_key = gr.Textbox(label="Google API Key (Required)", type="password", placeholder="Enter Google API Key for Gemini")
-
-                    summarize_btn = gr.Button("Summarize PR", variant="primary")
-
+                    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(scale=2):
-                     gr.Markdown("### PR Summary Output")
-                     pr_summary_output = gr.Markdown(label="Gemini PR Summary", value="PR Summary will appear here...")
-
-            # Wire the button click event
+                    pr_summary_output = gr.Markdown(label="PR Summary")
+            
             summarize_btn.click(
-                summarize_pr_gradio,
+                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 (optional, credentials can be entered in UI)
+    # Load environment variables
     load_dotenv()
-    print("Starting Gradio application...")
-
-    # Check if Gradio is available before launching
-    if not gr:
-         print("Gradio library is not available. Cannot launch UI.")
-         return
-
+    
     # Create and launch the Gradio interface
-    try:
-        app = create_gradio_interface()
-        if app:
-             # Set share=False for local testing, share=True to create public link (use with caution)
-             # Set debug=True for more detailed logs during development
-             app.launch(share=False, debug=True)
-        else:
-             print("Failed to create Gradio interface.")
-    except Exception as e:
-         print(f"Error launching Gradio app: {e}")
-         import traceback
-         traceback.print_exc()
+    app = create_gradio_interface()
+    app.launch(share=True)
 
 if __name__ == "__main__":
-    # Add basic checks for critical libraries before running main
-    if None in [gr, pd, np, requests, nx]:
-        missing = []
-        if not gr: missing.append("gradio")
-        if not pd: missing.append("pandas")
-        if not np: missing.append("numpy")
-        if not requests: missing.append("requests")
-        if not nx: missing.append("networkx")
-        print(f"Error: Missing critical libraries: {', '.join(missing)}. Please install them.")
-        print("e.g., pip install gradio pandas numpy requests networkx PyGithub neo4j google-generativeai vizro vizro-plotly plotly python-dotenv radon matplotlib")
-    else:
-        main()
\ No newline at end of file
+    main()
\ No newline at end of file