gl

gl finds the files a bug report is about. Point it at a repository and give it an issue. It ranks the source files most likely to need changes, in milliseconds on a laptop, with no LLM, no GPU and no index server.

Engineers triaging issues need this, and so does every AI coding agent before it can write a fix. This repo also tests, with real fixes as ground truth, whether a better search tool actually makes those agents better.

Quickstart

go install github.com/soham504/gl-code-search/go/cmd/gl@latest     # Go 1.22+

cd your-repo
gl locate < issue.txt                 # ranked likely files, with the reasons
gl search "date field serialization"  # code-aware ranked search with matching lines
gl symbol QuerySet                    # where it's defined
gl -k 5 -markdown locate < issue.txt  # ready to paste into an issue (also: -json)

Works on Python, JS/TS, Go, Rust, Java, Kotlin, Scala, C/C++, C#, Ruby and PHP. The first run analyses the repo. After that an on-disk cache re-analyses only changed files: 3.9 s → 0.25 s on Django's 2,600 files.

Related MCP server: Code Search MCP

Results

Acc@k is the share of issues where a file changed by the real fix is in the top k. Ground truth is always the actual fix, never our own labels. More benchmarks are running (SWE-Gym, LocBench, SWE-bench-Live, SWE-rebench, Multilingual, PolyBench); the full table with confidence intervals and per-language results is in eval/results/loc_summary.md.

Does better search help AI coding agents?

We gave the same agent the same 20 issues three times: with grep only, with grep + Graphify (a popular code knowledge graph), and with grep + gl. All 380 tool calls went through a logged harness with identical output caps.

Use it with your tools

gl mcp serves locate, search and symbol over stdio. It re-scans on every call (cheap thanks to the cache), so results stay fresh while the agent edits.

claude mcp add gl -- gl mcp                                        # Claude Code

{ "mcpServers": { "gl": { "command": "gl", "args": ["mcp"] } } }

Cursor: .cursor/mcp.json. Our A/B shows agents rarely pick a new tool unprompted, so tell yours to start with locate.

This posts the top-k likely files as a comment on every new issue. It's where gl measurably helps, because no LLM is in the loop.

# .github/workflows/issue-triage.yml in the repo you want triaged
on: { issues: { types: [opened] } }
permissions: { issues: write, contents: read }
jobs:
  suggest-files:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: soham504/gl-code-search@main
        with: { k: "5" }

The comment format is tested locally; the Action hasn't been run on a real repository yet.

How it works

flowchart LR
    I["Issue text"] --> Q["Signals: stack-trace frames, file paths, dotted modules, backticked symbols"]
    I --> A
    R[("Repository")] --> A["Code-aware analyzer: camelCase / snake_case splitting, stemming, symbol + path fields"]
    A --> X[("BM25 index + symbol table, cached by file mtime")]
    X --> S["Score = BM25 + signal boosts − test-file penalty"]
    Q --> S
    S --> O["Ranked files + reasons"]
    O --> C1["CLI"] & C2["MCP server"] & C3["GitHub Action"]

make test                                                   # Go + Python unit tests
python3 -m venv .venv && .venv/bin/pip install pyarrow -e '.[dev]'
.venv/bin/python harness/datasets.py                        # 8 public benchmarks → data/bench/
go build -o bin/locbench ./go/cmd/locbench
./bin/locbench -data data/bench/swebench_verified.jsonl -repos data/repos -name verified -fetch -j 8
python3 harness/mine.py > data/fresh/instances.jsonl        # fresh post-cutoff issues from git history
.venv/bin/python -m groundline.locsummary                   # cross-benchmark table
.venv/bin/python -m groundline.readme_assets                # regenerate the charts on this page

The agent A/B prompt and workflow are in harness/agent_ab.workflow.js; the dispatcher that enforces each toolkit is harness/tool.py.

Limitations

• Small agent study: 20 issues per condition and one model; tools were offered, not required.

• Simple symbol extraction: it's regex-based. It finds types but not methods in Java and C#.

• Fresh-issue gold isn't hand-checked: it comes from Fixes #N commits.

See docs/findings.md for the rest.

MIT licensed. Built with Go, plain BM25, and careful measurement.