A Val Town project that finds email addresses associated with a GitHub user by analyzing their public commit history using multiple methods.

Visit the live demo to try it out!

• Multiple Discovery Methods: Choose from 4 different search strategies
• Smart Early Stopping: Default method stops after finding emails, saving API calls
• Method Selection: Pick the best approach for your needs (speed vs. comprehensiveness)
• Smart Filtering: Automatically filters out GitHub's noreply email addresses
• Ranked Results: Shows emails ranked by frequency of use in commits
• Debug Information: Collapsible metadata section with execution details
• View Source: Easy access to the code with a header button
• Rate Limit Friendly: Includes delays and error handling to respect GitHub's API limits
• Clean UI: Modern, responsive interface built with Hono JSX and Tailwind CSS
• Modular Architecture: Well-organized codebase with separated concerns

The tool offers four different discovery methods to find email addresses:

• Fetches the user's recent public events (up to 100)
• Filters for PushEvent activities
• Extracts email addresses from commit authors in those events
• Pros: Fast, single API call, good for active users
• Cons: Limited to recent public activity, may miss older emails

• Gets the user's 10 most recently updated repositories
• Fetches the last 10 commits from each repository (authored by the user)
• Extracts email addresses from commit metadata
• Pros: More comprehensive, can find emails from older commits
• Cons: Multiple API calls, slower execution

• Tries the Events method first
• If emails are found, returns immediately (early stopping)
• If no emails found, falls back to Commits method
• Pros: Efficient, fast for active users, comprehensive fallback
• Cons: May miss some emails if early stopping occurs

• Runs both Events and Commits methods simultaneously
• Merges and deduplicates results from both sources
• Aggregates commit counts across both methods
• Pros: Most comprehensive, combines all available data
• Cons: Uses maximum API calls, slower execution

├── index.ts                    # Main HTTP endpoint with method selection
├── components/
│   ├── Layout.tsx             # Main layout with view source button
│   ├── SearchForm.tsx         # Search form with method selection
│   ├── ResultsTable.tsx       # Results display with debug metadata
│   └── ErrorMessage.tsx       # Error display component
├── lib/
│   ├── github-combined.ts     # Combined search strategies
│   ├── github-events.ts       # Events-based email discovery
│   └── github-commits.ts      # Commits-based email discovery
├── types/
│   └── github.ts              # TypeScript interfaces
├── github-events.ts           # Legacy combined implementation
├── demo.tsx                   # Legacy demo interface
└── README.md                  # This file

• Runtime: Deno on Val Town
• Framework: Hono for HTTP handling
• UI: Server-side JSX with Tailwind CSS
• API: GitHub REST API v4

• Uses Val Town's proxied fetch to help with rate limits
• Supports optional GITHUB_TOKEN environment variable for higher rate limits
• Includes 100ms delays between repository API calls
• Graceful error handling for failed requests

GITHUB_TOKEN=your_github_personal_access_token

Adding a GitHub token increases your rate limit from 60 to 5,000 requests per hour.

1. Clone or fork this Val Town project
2. Set up your GITHUB_TOKEN if desired
3. The main entry point is index.ts (HTTP endpoint)
4. Use the "View Source" button in the UI to access the code directly

import { 
  getGithubUserEmail,           // Smart combined (recommended)
  getGithubUserEmailCombined,   // Full combined approach
  getGithubUserEmailFromEvents, // Events-only method
  getGithubUserEmailFromCommits // Commits-only method
} from "./lib/github-combined.ts";

// Get emails using smart combined approach (default)
const emails = await getGithubUserEmail("username");

// Get emails using full combined approach
const allEmails = await getGithubUserEmailCombined("username");

// Get emails from events only
const eventEmails = await getGithubUserEmailFromEvents("username");

// Get emails from commits only  
const commitEmails = await getGithubUserEmailFromCommits("username");

// Results format
interface EmailOccurrence {
  username: string;    // Author name from commits
  email: string;       // Email address
  commitCount: number; // Number of commits using this email
}

# Web interface with method selection
GET /?username=octocat&method=combined

# Available methods:
# - combined (default): Smart combined with early stopping
# - events: Events only
# - commits: Commits only  
# - full-combined: Full combined approach

# Returns HTML page with results and debug information

Choose from four different discovery strategies:

• Smart Combined (Default): Efficient with early stopping
• Events Only: Fast, single API call
• Commits Only: Comprehensive repository scanning
• Full Combined: Maximum coverage, all methods

Collapsible metadata section showing:

• Execution method and time
• API calls made
• Coverage details
• Result count and timestamp

Detailed debug section below results table with:

• Raw API Responses: Complete GitHub API responses
• All Events: Full event data from GitHub's events API
• Push Events: Filtered push events with commit data
• Repository Details: Information about processed repositories
• Commit Processing: Step-by-step commit analysis
• Email Filtering: Before/after noreply email filtering
• API Call Tracking: URLs, status codes, and timestamps
• Error Logging: Detailed error messages and stack traces
• Performance Metrics: Execution times and resource usage

• Header button links directly to Val Town source code
• Easy access for developers and contributors
• Seamless integration with Val Town's development workflow

• Only analyzes public repositories and commits
• Respects users who have configured private emails
• Filters out GitHub's @users.noreply.github.com addresses
• Use responsibly and respect privacy

• GitHub API rate limits (60/hour without token, 5000/hour with token)
• Only finds emails from commits where the user is the author
• May miss emails from private repositories or private commits
• Results depend on user's commit history and email configuration

• Email addresses found may be outdated
• Users can configure different emails for different repositories
• Some commits may use organization or work emails
• Results are ranked by frequency, not recency

The application handles various error scenarios:

• Invalid usernames
• API rate limit exceeded
• Network timeouts
• Private or empty repositories
• Malformed API responses

Errors are logged to console and displayed to users with helpful messages.

This is a Val Town project. To contribute:

1. Fork the project in Val Town
2. Make your changes
3. Test thoroughly
4. Share your improvements!

This project is open source and available under standard Val Town terms.

This tool is for educational and legitimate research purposes only. Always respect privacy, follow GitHub's Terms of Service, and use responsibly. The authors are not responsible for misuse of this tool.

• Enhanced Method Selection: Four different discovery strategies with clear descriptions
• Comprehensive Debug Information: Two-level debug system with summary and detailed data
• Raw Data Access: Complete API responses, events, commits, and processing details
• Performance Monitoring: Detailed execution metrics and API call tracking
• Error Diagnostics: Complete error logging and troubleshooting information
• View Source Integration: Direct link to Val Town source code in the header
• Improved UI: Better form layout with method selection and enhanced user experience
• Developer Tools: Extensive debugging capabilities for analysis and optimization