Add team qualifier to code search 👥 👥

[Avivhdr]

Hello Github team 👋🏼

Please add an option to add a team qualifier to the code search.

In our organization, we have countless repositories and teams.

We need to search for a specific use of a method inside our repositories and notify each team that uses this method that they need to deprecate it.
If I had the team qualifier, each team could search array.badMethod team:team-x and find a list that contains all (and only) the instances of that method that they need to work on.

Currently, if I search for and find the method in a repository, even after opening and viewing the repository I can't see which team owns it and I have to rely on the contributors section, which at times contains members that are no longer in the organization.
There is an open issue on that so I would like it here as well 😉
#9021

Thank you 🙏🏼

[Avivhdr]

Hi @look 👋🏼
Did you have a chance to read this feedback? 🤞🏼

[colinwm]

Hey @Avivhdr, that's a nice idea. We don't currently have team info in the index right now.

As a possible workaround, teams can create custom scopes with repositories relevant to their team. Click on the scope dropdown to the left of the search box, scroll to the bottom and click "Custom scopes". Once a team creates a custom scope, they can share it by just sharing the scope's URL.

Obviously not as good as having a team qualifier, but might be useful in the meantime.

[Avivhdr]

Hi @colinwm,

Unfortunately, this solution is not viable in our case.
We have over 60 teams and many individuals are members of more than one team.
That would be a lot of work, hard to maintain, and would not be worth the effort.

Just to adjust my expectations, what is the likelihood that a team qualifier will be introduced to the new code search (0% - 100%)?

Thank you for all your hard work 🙏🏼

[Avivhdr]

Though after using Custom Scopes for other cases, I have to say that it is an awesome feature!

[colinwm]

what is the likelihood that a team qualifier will be introduced

I'm going to look into implementing the team qualifier, since there is clearly a good amount of interest. It seems like it should be doable.

Though after using Custom Scopes for other cases, I have to say that it is an awesome feature!

Glad you like it! And don't forget to set a default scope via the homepage (cs.github.com) too!

[Avivhdr]

Yeah, that's how I use it. I'm working on a group of about 15 repositories (out of 1000 in our org) and usually, I'm only interested in those, so the costume scope was a perfect fit!
🙏🏼 🙇🏼

[Avivhdr]

Hi @colinwm,
I played with it a bit more and I found a few issues : #11714

[csumpter]

I see this request duplicated in a few places, but would also appreciate it.

[Avivhdr]

I also open this ticket, which suggests adding team information on the main repository page.

[jaknor]

Would love to see this feature implemented.

Filtering on repositories works but not feasible to maintain long term.

Until this is implemented I wrote a small node app which will query the Github API for the repositories belonging to a team and create queries to filter on them. This should at least make keeping the custom scopes up to date a bit easier even though it does not solve the issue of having to query multiple times if your team has a lot of repositories as it is still limited by the 500 query character limit (it will generate multiple queries if a query becomes too long)

[zottinor]

I'm looking for this feature to search by team.

[gkelly-tvpt]

Is there any movement on this issue?

[ericsteele-8451]

I would also be interested in the ability to search within my team's repositories. I tried looking for custom scopes, but can't find that feature in the search UI.

When we were using Github Enterprise, my team had our own org which made searching easy. Now that we've migrated to Github.com, the org is company wide. I'm in a situation were I'd like to quickly check my team's repos for usage of a particular string, and don't have a good way to do that.

[Thunderforge]

It sounds like indexing the teams that have access (of any level?) to a repository would work for your use cases.

Yes, any level makes sense. The lowest level is Read access, and since the point of searching is to locate code (not necessarily to edit that code), having team:FooBar scan repos where the team has Read access or higher makes sense.

If additional search parameters were available that checked for other levels of access, that might be useful in some cases, but would be extra.

[ericsteele-8451]

It sounds like indexing the teams that have access (of any level?) to a repository would work for your use cases.

Absolutely. Being able to search through any repositories that my team has been granted some access to would do what I'm looking for. Glad to hear that this is something on your radar @look, thank you!

I could envision a situation where the level of access could matter (e.g. if an org had most repositories private rather than internal, and controlled visibility through Read access), but that doesn't apply to me.

[abvm659]

I am pretty sure this need is common for all enterprise organizations unless they create organization per team (which is nonsense). Github is so terrible in enterprise features, I really don't understand why we are still using it

[adamsxs]

My team at work could really use this feature. Just more examples of what @Thunderforge and @ericsteele-8451 have said above, the ability to search for repo prefixes with regex search or a specific access level for our team name would be really helpful!
We've got 82 repos and growing, and these would help filter out results from some of the other >1k repos under our org, so unfortunately custom scopes don't really scale for our needs.

[jmaixl]

I am in the same position, where indexing more information about teams and repositories for code search would make a BIG difference.

If not repository regexes or team names (strong preference), but even searching by repository topic would great.

[rinnan17]

Any news here?

[rschoenrock-rga]

Implementing this as described by the OP would be amazing for us. +1 from me!

[nahue-gonzalez]

Any updates on this? It's been a long time since I'm waiting for it already 😁

[amrocco]

@colinwm What gives? This feature is a no-brainer. It's shocking that the teams concept was launched without this, and appalling that years later is still doesn't exist.

[rajput-rana]

Is this feature coming? Any possible workarounds it would be super useful and time saving when a code needs to be searched in particular team repos.

[dorszpw]

It's a must for any multi-team organization. Otherwise code search is close to useless... coming from Azure DevOps it's really a pain.

[ericsteele-8451]

@ranasimpplr on the subject of workarounds, I've been using a Python script and PyGithub to do this search. It adds repo: qualifiers to your search until you hit the max query length to minimize the number of code searches. I like to manually check the repos myself so it just returns the repo URLs, but this could probably be modified to output the actual search results.

edit: looking at the Github API, I realized that I was being too conservative with the character length for queries. The 256 character limit mentioned does not include qualifiers. There is some kind of overall character limit beyond the 4000 repository limit mentioned on that page, but I don't know what that overall limit actually is. Play around with values maybe?

https://docs.github.com/en/rest/search/search?apiVersion=2022-11-28#limitations-on-query-length

from github import Github
from github.Repository import Repository
from pprint import pprint


def github_code_search_repos(github: Github, queries: list[str]) -> list[Repository]:
    """Executes the provided queries, and combines results

    :param Github github:  Github API class from PyGithub
    :param list[str] queries: Queries to execute
    :return list[Repository]: Combined repositories returned by queries
    """
    total_queries = len(queries)
    results = []

    # run all queries
    # no retry logic because that's now implemented in PyGithub
    for index, query in enumerate(queries):
        print(f'Running query {index + 1} of {total_queries}')
        response = g.search_code(query)
        results.extend(response)
    return [result.repository for result in results]


def search_git_by_team(github: Github, search_query: str, org_name: str, team_name: str) -> set[str]:
    """Searches Github code using the provided query in repos for the specified org and team

    :param Github github: Github API class from PyGithub
    :param str search_query: Query for Github code search
    :param str org_name: Github Org to search
    :param str team_name: Team within Org whose repos should be searched
    :return set[str]: A set of URLs for repos that had results for the Github code search
    """
    # Get repos to search
    org = g.get_organization(org_name)
    team = org.get_team_by_slug(team_name)
    repos = team.get_repos()
    repo_full_names = [repo.full_name for repo in repos]
    print(f'Found {len(repo_full_names)} repos for team {team_name} in {org_name}')

    # Determine how many characters we have available in search string for "repo:" qualifiers after search term(s)
    max_qualifier_length = 255 - len(search_query)

    # Combine repos into queries
    queries = []
    while repo_full_names:
        # Start building a new query
        current_qualifiers = [f'repo:{repo_full_names.pop()}']
        current_length = len(current_qualifiers[0])
        # Add more repos to the current query
        while repo_full_names:
            next_repo = repo_full_names.pop()
            new_length = len(next_repo) + current_length + 6  # six characters for " repo:"
            # check if new qualifier would be too long
            if new_length <= max_qualifier_length:
                current_qualifiers.append(f'repo:{next_repo}')
                current_length = new_length
            else:
                # if too long, requeue next repo and stop adding more
                repo_full_names.append(next_repo)
                break

        # Character limit hit, build the complete query
        current_qualifiers.append(search_query)
        qualified_query = ' '.join(current_qualifiers)
        queries.append(qualified_query)
    
    # Queries assembled to cover all team's repos, now execute and combine results
    print(f'Condensed repos to {len(queries)} queries.')
    return set(repo.html_url for repo in github_code_search_repos(github, queries))

if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('search_string', help='Search term for Github code search')
    parser.add_argument('target_org', help='Github Org to search')
    parser.add_argument('target_team', help='Team whose repos should be searched')
    args = parser.parse_args()

    with open('.github_access_token', 'r') as f:
        access_token = f.readline().strip()

    g = Github(access_token)

    results = search_git_by_team(g, args.search_string, args.target_org, args.target_team)
    pprint(results)

[Zoooook]

Github also recommends grouping multiple teams into an organization, so it would be nice if they would make their preferred organizational structure actually usable from a search standpoint.

[frizzr]

This point is particularly true. We moved from a team per org to many teams per org because of the very document listed above, so Github should at least be consistent with their own recommendations and provide search by team repositories.