GitTrek solves the silent GitHub PR problem with live issue tracking

Every developer has experienced this frustration: you spot a well-labeled GitHub issue, set up your environment, and dive into solving it—only to later discover someone else quietly started working on the same problem weeks ago. Comments like "I’ll handle this soon" appear days too late, turning hours of effort into wasted work. The issue isn’t a lack of tools; it’s that existing platforms like goodfirstissue.dev and up-for-grabs.net rely on static or outdated data, leaving contributors blind to live competition.

That’s exactly why GitTrek was created. This open-source tool doesn’t just list beginner-friendly issues—it tracks the real-time status of every issue by monitoring subtle signals developers leave behind. Whether someone mentions the issue number in a pull request or links a branch to it, GitTrek catches these traces instantly, sparing you from duplicated work.

The silent claiming problem: Why current tools fail

Most issue discovery platforms operate on a simple model: they scrape or curate a list of issues marked as "good first issue" or "help wanted," and present them to users. But these tools suffer from a critical flaw—they lack visibility into who is already working on an issue right now. Developers often begin coding without leaving a comment or formally claiming the task, leaving the issue open for others to stumble upon.

GitTrek addresses this gap by detecting two types of hidden signals:

• Pull request mentions: When a developer references an issue in a PR description or commit message using Fixes #847, GitHub creates a CROSS_REFERENCED_EVENT in the issue’s timeline.
• Linked branches: When someone creates a branch tied to an issue and later converts it into a PR, GitHub logs a CONNECTED_EVENT in the issue’s history.

These events are invisible to traditional discovery tools because they require querying GitHub’s GraphQL API in real time—a capability most platforms ignore.

Decoding GitHub’s GraphQL: The key events behind GitTrek

GitTrek’s detection engine revolves around two GraphQL event types exposed via the timelineItems field on every GitHub issue. Understanding these events is critical to avoiding common pitfalls:

`CROSS_REFERENCED_EVENT`

• Triggered when an issue number (#123) is mentioned in a PR or commit.
• The PR is stored in the event’s source field.

`CONNECTED_EVENT`

• Triggered when a branch linked to an issue becomes a PR.
• The PR is stored in the event’s subject field, not source—a nuance that trips up many developers.

A common mistake is mixing up source and subject in queries, which leads to silent errors and null results. GitTrek avoids this by explicitly handling both event types in its GraphQL query:

issue(number: $issueNumber) {
  timelineItems(
    first: 25,
    itemTypes: [CROSS_REFERENCED_EVENT, CONNECTED_EVENT]
  ) {
    nodes {
      ... on CrossReferencedEvent {
        source {
          ... on PullRequest {
            number
            state
            isDraft
          }
        }
      }
      ... on ConnectedEvent {
        subject {
          ... on PullRequest {
            number
            state
            isDraft
          }
        }
      }
    }
  }
  linkedBranches(first: 3) {
    totalCount
  }
}

By combining these checks with a count of linked branches, GitTrek builds a clear picture of an issue’s current status—before you start coding.

Instant visibility: How GitTrek colors your search results

GitTrek doesn’t just detect hidden PRs—it visualizes the competition in real time using a color-coded system that updates instantly:

• 🔴 Active PR – An open, non-draft PR exists. Contributing now means direct competition with someone already mid-development.
• 🟡 Someone started – A draft PR is linked to the issue. You can proceed, but tread carefully—this developer may finalize it soon.
• 🟡 Branch exists – A branch is linked to the issue, but no PR has been opened yet. This signals early-stage work; proceed with caution.
• ✅ Safe to claim – No linked PRs or branches are detected. You’re free to work without overlap.

This system empowers contributors to make informed decisions in seconds, eliminating the guesswork from open-source collaboration.

Performance without compromise: Parallel checks for a seamless experience

GitTrek doesn’t slow you down. When you search for 20 issues, the tool doesn’t wait for each status check to complete before showing results. Instead, it follows a "hydration" approach:

• Results appear immediately, even if some status checks haven’t finished.
• Background API calls fetch badge data and issue statuses in parallel.
• Even if one check fails due to rate limits or permission issues, the rest of your dashboard remains fully functional.

This is achieved using Promise.allSettled, which processes all asynchronous calls independently:

const settlements = await Promise.allSettled([
  fetch(`/api/github/badges/pull-shark?username=${user}`).then(r => r.json()),
  fetch(`/api/github/badges/starstruck?username=${user}`).then(r => r.json()),
  // Additional badge checks
]);

const [pullShark, starstruck] = settlements.map(s => 
  s.status === "fulfilled" ? s.value : { count: 0 }
);

By prioritizing resilience over perfect data, GitTrek ensures a smooth, frustration-free experience—even under imperfect conditions.

Beyond issue tracking: A companion for open-source growth

GitTrek isn’t just a safety net for avoiding duplicated work—it’s a growth engine for open-source contributors. The tool includes several advanced features designed to help developers level up efficiently:

• Repository quality gates: Filter issues by star count, fork count, and whether the repo has a CONTRIBUTING.md file—ensuring you only contribute to well-maintained projects.
• Live badge tracking: Monitor progress toward GitHub achievement badges like Pull Shark, Galaxy Brain, and YOLO using real-time GraphQL calculations.
• Focus Missions: When you’re close to earning a badge, GitTrek generates customized search queries to help you find the exact issues needed to reach your goal.

For example, if you’re just two pull requests away from the Gold Pull Shark badge, GitTrek will curate a list of high-impact issues that match your skill level and repository preferences.

Try GitTrek today—no setup required

GitTrek is completely free and open source. You can start browsing issues immediately without connecting your GitHub account. Only when you want to track your personal badge progress or save your progress will you need to authenticate.

The project is actively maintained, with the source code available for contributions and transparency. Whether you’re a first-time contributor or a seasoned open-source veteran, GitTrek helps you contribute smarter—not harder.

The open-source community thrives on collaboration, but it also depends on respecting the work of others. With tools like GitTrek, we can reduce wasted effort, increase transparency, and make every contribution count—without sacrificing speed or quality.