chrome extension

Author: LachlanGray

showcase/code-analysis/README.md

@@ -1,9 +1,27 @@
-# Code Analysis CLI
+# GitHub Repository Analyzer
 
-A Python CLI application for analyzing GitHub repository complexity.
+A Chrome extension that analyzes GitHub repositories for development patterns and metrics.
 
-## Setup
+## Features
+- Commit frequency analysis
+- Contributor activity tracking
+- Commit patterns by weekday
+- Average commit size metrics
+
+## Prerequisites
+- Python 3.8 or higher
+- Google Chrome browser
+- Git
+
+## Setup Instructions
+
+### 1. Clone the Repository
+```bash
+git clone <your-repo-url>
+cd code-analysis
+```
 
+### 2. Set Up Python Environment
 ```bash
 # Create and activate virtual environment
 python -m venv .venv
@@ -16,35 +34,60 @@ pip install -e .
 pip install -e ".[dev]"
 ```
 
-## Usage
-
+### 3. Start the Backend Server
 ```bash
-# List available commands
-python -m cli --help
-
-# Analyze commit frequency for a repository
-python -m cli analyze_commit_frequency /path/to/git/repo
-
-# Output results in JSON format
-python -m cli analyze_commit_frequency /path/to/git/repo --json
+# Start the FastAPI server
+./start_server.sh
 ```
+The server will run at http://localhost:8000
 
-## Features
+### 4. Install Chrome Extension
+1. Open Chrome and navigate to `chrome://extensions/`
+2. Enable "Developer mode" in the top right
+3. Click "Load unpacked"
+4. Select the `extension` directory from this project
 
-- analyze_commit_frequency: Analyze commit frequency by day
-- More features coming soon!
+### 5. Using the Extension
+1. Navigate to any GitHub repository
+2. Click the extension icon in Chrome's toolbar
+3. Click "Analyze Repository" to see metrics
 
 ## Development
 
+### Running Type Checks
 ```bash
-# Run type checker
 mypy cli app
+```
 
-# Format code
+### Format Code
+```bash
 black cli app
-
-# Run FastAPI server
-uvicorn app.main:app --reload
 ```
 
-The FastAPI app will be available at http://localhost:8000 with automatic API documentation at http://localhost:8000/docs.
+### API Documentation
+When the server is running, visit:
+- http://localhost:8000/docs for interactive API documentation
+- http://localhost:8000/redoc for alternative documentation view
+
+## Troubleshooting
+
+### Common Issues
+1. If the extension shows "No repository detected":
+   - Refresh the GitHub page
+   - Make sure you're on a repository page
+
+2. If analysis fails:
+   - Check that the backend server is running
+   - Look for errors in the server logs
+
+3. If the extension doesn't load:
+   - Check Chrome's extension page for errors
+   - Try reloading the extension
+
+### Server Logs
+The FastAPI server logs all operations. Check the terminal where you ran `start_server.sh` for detailed error messages.
+
+## Architecture
+- `cli/`: Command-line interface for git analysis
+- `app/`: FastAPI web service
+- `extension/`: Chrome extension files

showcase/code-analysis/app/__init__.py

@@ -0,0 +1 @@
+"""FastAPI application for git repository analysis."""

showcase/code-analysis/app/main.py

@@ -0,0 +1,109 @@
+import os
+import tempfile
+import logging
+from git import Repo
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from typing import Dict, Union
+from pydantic import BaseModel
+from cli.git_analysis import (
+    analyze_commit_frequency,
+    analyze_contributor_activity,
+    analyze_commit_frequency_by_weekday,
+    analyze_commit_frequency_by_hour,
+    analyze_average_commit_size,
+    analyze_file_change_frequency,
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Git Analysis API")
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["chrome-extension://*"],  # Allow requests from any Chrome extension
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Store repo paths temporarily
+repo_cache: Dict[str, str] = {}
+
+
+class CloneRequest(BaseModel):
+    url: str
+
+
+@app.post("/clone")
+async def clone_repository(request: CloneRequest) -> Dict[str, str]:
+    """Clone a git repository and return a temporary ID to reference it."""
+    try:
+        # Create a temporary directory
+        temp_dir = tempfile.mkdtemp()
+        logger.info(f"Created temp directory: {temp_dir}")
+
+        # Clone the repository
+        logger.info(f"Cloning repository from {request.url}")
+        repo = Repo.clone_from(request.url, temp_dir)
+
+        # Generate a simple ID (you might want to use UUID in production)
+        repo_id = str(hash(request.url))
+
+        # Store the mapping
+        repo_cache[repo_id] = temp_dir
+        logger.info(f"Successfully cloned repository. ID: {repo_id}")
+
+        return {"repo_id": repo_id}
+    except Exception as e:
+        logger.error(f"Error cloning repository: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/analyze/{analysis_type}")
+async def analyze_repo(
+    analysis_type: str, repo_id: str
+) -> Dict[str, Union[int, float]]:
+    """Analyze a git repository using the specified analysis type."""
+    try:
+        # Get repo path from cache
+        repo_path = repo_cache.get(repo_id)
+        if not repo_path:
+            logger.error(f"Repository not found for ID: {repo_id}")
+            raise HTTPException(
+                status_code=404, detail="Repository not found. Please clone it first."
+            )
+
+        logger.info(f"Analyzing repository at {repo_path}")
+
+        analysis_functions = {
+            "commit-frequency": analyze_commit_frequency,
+            "contributor-activity": analyze_contributor_activity,
+            "commit-frequency-by-weekday": analyze_commit_frequency_by_weekday,
+            "commit-frequency-by-hour": analyze_commit_frequency_by_hour,
+            "average-commit-size": analyze_average_commit_size,
+            "file-change-frequency": analyze_file_change_frequency,
+        }
+
+        if analysis_type not in analysis_functions:
+            logger.error(f"Invalid analysis type: {analysis_type}")
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid analysis type. Must be one of: {', '.join(analysis_functions.keys())}",
+            )  # Execute analysis
+        logger.info(f"Running {analysis_type} analysis")
+        results = analysis_functions[analysis_type](repo_path)
+        logger.info(f"Analysis complete: {results}")
+
+        # Cast the dictionary to the expected type
+        if not isinstance(results, dict):
+            raise HTTPException(
+                status_code=500, detail="Analysis returned invalid type"
+            )
+        return results
+    except Exception as e:
+        logger.error(f"Error during analysis: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

showcase/code-analysis/cli/git_analysis.py

@@ -0,0 +1,133 @@
+from typing import Dict
+from git import Repo
+from datetime import datetime, timezone
+from collections import defaultdict
+
+
+def analyze_commit_frequency(repo_path: str) -> Dict[str, int]:
+    """Analyze commit frequency by day for a git repository."""
+    repo = Repo(repo_path)
+    frequency: Dict[str, int] = defaultdict(int)
+
+    for commit in repo.iter_commits():
+        date = datetime.fromtimestamp(commit.committed_date, timezone.utc)
+        day = date.strftime("%Y-%m-%d")
+        frequency[day] += 1
+
+    return dict(frequency)
+
+
+def analyze_commit_frequency_by_weekday(repo_path: str) -> Dict[str, int]:
+    """
+    Analyze commit frequency by weekday (e.g., Monday, Tuesday).
+    """
+    repo = Repo(repo_path)
+    # Initialize all weekdays with zero count
+    frequency = {
+        "Monday": 0,
+        "Tuesday": 0,
+        "Wednesday": 0,
+        "Thursday": 0,
+        "Friday": 0,
+        "Saturday": 0,
+        "Sunday": 0,
+    }
+
+    for commit in repo.iter_commits():
+        date = datetime.fromtimestamp(commit.committed_date, timezone.utc)
+        weekday = date.strftime("%A")  # e.g., "Monday"
+        frequency[weekday] += 1
+
+    return frequency
+
+
+def analyze_commit_frequency_by_hour(repo_path: str) -> Dict[str, int]:
+    """
+    Analyze commit frequency by hour of day (0-23).
+    """
+    repo = Repo(repo_path)
+    # Initialize all hours with zero count
+    frequency = {f"{hour:02d}": 0 for hour in range(24)}
+
+    for commit in repo.iter_commits():
+        date = datetime.fromtimestamp(commit.committed_date, timezone.utc)
+        hour = date.strftime("%H")  # e.g., "13" for 1pm
+        frequency[hour] += 1
+
+    return frequency
+
+
+def analyze_average_commit_size(repo_path: str) -> Dict[str, float]:
+    """
+    Compute the average commit size (approximate lines added or removed per commit).
+    """
+    repo = Repo(repo_path)
+    total_changes = 0
+    commit_count = 0
+
+    for commit in repo.iter_commits():
+        # If the commit has no parent (e.g., the initial commit), skip
+        if not commit.parents:
+            continue
+
+        # Compare commit to its first parent
+        diffs = commit.diff(commit.parents[0], create_patch=True)
+        changes_in_commit = 0
+        for diff in diffs:
+            if not diff.diff:
+                continue
+            # diff.diff can be either string or bytes
+            # A rough approach is to count the number of lines that start with "+" or "-"
+            # ignoring lines that start with "+++" or "---" in the patch header
+            if isinstance(diff.diff, bytes):
+                patch_lines = diff.diff.decode("utf-8", errors="ignore").split("\n")
+            else:
+                patch_lines = diff.diff.split("\n")
+            for line in patch_lines:
+                if line.startswith("+") and not line.startswith("+++"):
+                    changes_in_commit += 1
+                elif line.startswith("-") and not line.startswith("---"):
+                    changes_in_commit += 1
+
+        total_changes += changes_in_commit
+        commit_count += 1
+
+    average_changes = total_changes / commit_count if commit_count else 0
+    return {"average_commit_size": average_changes}
+
+
+def analyze_file_change_frequency(repo_path: str) -> Dict[str, int]:
+    """
+    Analyze how often each file is changed in the repository.
+    """
+    repo = Repo(repo_path)
+    file_frequency: Dict[str, int] = defaultdict(int)
+
+    for commit in repo.iter_commits():
+        # Skip the initial commit (no parent to compare against)
+        if not commit.parents:
+            continue
+
+        parent = commit.parents[0]
+        # diff() returns a list of diff objects representing file changes
+        diffs = commit.diff(parent)
+
+        for diff in diffs:
+            # a_path and b_path might be different if the file was renamed
+            file_path = diff.a_path or diff.b_path
+            if file_path:  # Only count if we have a valid path
+                file_frequency[file_path] += 1
+
+    return dict(file_frequency)
+
+
+def analyze_contributor_activity(repo_path: str) -> Dict[str, int]:
+    """Analyze commit count per contributor in a git repository."""
+    repo = Repo(repo_path)
+    activity: Dict[str, int] = defaultdict(int)
+
+    for commit in repo.iter_commits():
+        author = f"{commit.author.name} <{commit.author.email}>"
+        activity[author] += 1
+
+    return dict(activity)

showcase/code-analysis/extension/background.js

@@ -0,0 +1,17 @@
+// Store repository info from content scripts
+let currentRepoInfo = null;
+
+// Listen for messages from content script
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message.type === 'REPO_DETECTED') {
+    currentRepoInfo = message.data;
+  }
+});
+
+// Listen for messages from popup
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message.type === 'GET_REPO_INFO') {
+    sendResponse({ data: currentRepoInfo });
+  }
+  return true; // Keep channel open for async response
+});