jev.nvim

# jev.nvim

[](https://github.com/valentynkit/jev.nvim/actions/workflows/ci.yml)



Ask the buffer a question in plain language. Every function in it gets judged, and the
answers land in quickfix ranked by probability.

```vim
:Jev builds a SQL query by string concatenation
```



## What the clip shows

It opens on the grep you write when you go looking for SQL injection:

```console
$ rg -n 'SELECT.*\+' fixtures/corpus/
5 matches
```

Five, and every one of them is a `+`. There are twelve. Lua concatenates with `..`, Rust
with `format!`, Python with an f-string, TypeScript with a template literal. One idea,
five syntaxes, and the regex that catches one catches none of the rest. That is not noise,
it is a false negative: you searched, you got five, you stopped.

Then the same question in English, over the same twelve files:

```
errors.rs |14 col 1| 0.98  find_user
errors.ts |14 col 1| 0.97  findUser
errors.py |20 col 1| 0.96  find_user
errors.js |13 col 1| 0.95  findUser
report.rs |15 col 1| 0.95  report_query
errors.go |20 col 1| 0.94  findUser
errors.lua|14 col 1| 0.93  M.find_user
report.py |14 col 1| 0.93  report_query
```

grep is shaped like the language. The question is not.

The clip is rendered against the plugin's test fake so it runs from a clean clone, which
means the probabilities in it are fixtures rather than measurements. `demo/README.md` lists
exactly what is staged for the camera and what is not.

## Why

grep needs the pattern, and half the searches worth running have no pattern. "Where do we
retry without a backoff." "Which handlers touch the database before checking auth." "What
swallows an exception and returns a default." You know the shape of the answer, not the
string.

jev.nvim splits the buffer with treesitter and sends one question per func