https://github.com/parwest/peeper-picker.nvim

v1.1.0 adds peek history to peeper-picker.

peek history

:PeeperPickerHistory opens a plain list of the symbols you recently peeked, newest first.

• <CR> peeks a name again, without moving your cursor or touching your current buffer. three files deep in a refactor, you can re-check anything you looked at earlier and not lose your place
• c clears the list (asks first), q/<Esc> close
• one entry per name, repeat peeks move it to the top
• session only, in memory, nothing written to disk. bounded by history_size (default 100, 0 disables)

renames

history pins each name to the spot you peeked it. peek oldName, rename it to newName, and:

• the list still shows oldName — you never peeked newName, so it doesn't pretend you did
• selecting oldName runs a text search for it, which returns exactly the occurrences the rename didn't touch: strings, comments, docs, files the server doesn't index
• a name that still resolves to a live symbol runs a normal full peek

also shipped in 1.0.0

• results grouped by file with folding: J/K jump between files, zo/zc/za/zM/zR work, <CR> on a file header collapses it
• ? opens a key cheatsheet inside the picker
• decl is its own tag now instead of sharing def

setup

{

  "parwest/peeper-picker.nvim",

  main = "peeper_picker",

  cmd = { "PeeperPicker", "PeeperPickerHistory" },

  opts = {},

  keys = {

    { "<leader>pp", "<cmd>PeeperPicker<cr>", desc = "Peeper Picker" },

    { "<leader>ph", "<cmd>PeeperPickerHistory<cr>", desc = "Peeper Picker History" },

  },

}

still zero external dependencies, but needs an attached LSP client.

would love any and all feedback,

thanks to everyone who has reached out with feature requests!

https://github.com/parwest/peeper-picker.nvim

https://github.com/parwest/tmux-spoony

tmux-spoony is (still) a copy mode helper that automagically grabs the url / path / command prompt + output block, and now, git shas!

this release adds a few bigger things since the last post:

git sha selector: s selects the git sha on the cursor line, and S jumps to the next sha below and keeps stepping through them. when you hit the last one, press S once more to wrap back to the first sha after the prompt that output them. main use case is running git log / git log --oneline and stepping through every commit hash hands-free. works with both SHA-1 and SHA-256, and it ignores plain numbers so timestamps / pids / line numbers don't get mistaken for hashes.

emacs copy-mode support: used to be vi-mode only. it now binds both copy-mode tables and works whichever one you're on (the help popup tells you which is active).

a proper help popup: press ? in copy mode and it pops a cheatsheet generated from your actual resolved keys, so it reflects any remaps, disabled keys, and derived cycle keys. it also shows the active copy-mode table and which prompt character(s) spoony is matching.

the basic flow still remains:

1. enter copy mode with prefix + [
2. move to the line you care about
3. press a selector key ( u urls, p paths, m command prompt, s git sha, x full line — uppercase variants cycle/extend within the same row, and S steps down through shas )
4. yank with your copy key (i use tmux-yank) or open with o (tested on mac and linux)

thanks to everyone who's reached out, the readme got an update with plenty of configuration info, including:

- rebind any selector key

- disable any key with `off` (restores tmux's native binding if spoony had overridden it)

- custom prompt matching via `@spoony-command-prompt-regex`, with presets for bash / zsh / fish / starship / oh-my-zsh, if you experience any mismatches against your m/M selections this is the culprit, setup your own custom regex pattern and you should be good to rock and roll.

https://github.com/parwest/tmux-spoony

https://github.com/parwest/peeper-picker.nvim

the language server is great for semantic stuff, but it misses things constantly. symbols in strings, templates, prose, comments, generated code, weird project roots, plain indexing gaps. the pattern that kept burning me: run "find references," get 4 hits, refactor confidently, then discover 3 more usages the server never told me about.

peeper-picker is a small picker for the symbol under your cursor that fixes this. it runs a workspace-wide text search alongside the LSP results and folds them together. you still get the confirmed semantic hits, but you also see every literal occurrence. crucially it doesn't pretend they're all the same — each hit is tagged:

• def — definition/declaration the lsp confirmed
• ref — an lsp reference, or a code-looking text match the server missed
• txt — match inside a string / template / prose
• com — match inside a comment

text/comment matches are de-duplicated against the lsp results, so you never see the same location twice. classification is done with tree-sitter (with a comment-prefix fallback).

filtering, for when a common symbol has 200 hits

the filter menu (f) is the part that's more specialized than a generic fuzzy finder:

• cycle scope between workspace, directory, or just the current file
• four-way result toggle: code, references, definitions, all
• inverted path/extension filters: a leading ! excludes, so !src/ hides everything under src, !test.js hides only your test files

other bits

• the workspace search streams results incrementally across scheduled ticks instead of blocking on one big grep, so a huge repo or a zero-match word never freezes the editor
• preview caches are bounded, so long browsing sessions stay light on memory
• ignored_dirs to skip extra folders during the text search

the basics

• :PeeperPicker to open (optional <leader>pp, off by default)
• <CR> open, <C-v>/<C-x>/<C-t> vsplit/split/tab, j/k move (including 5j/4k etc...), f filters, q/<Esc> close
• zero external dependencies (tree-sitter is recommended; but with no attached LSP it just tells you so and fails to launch with a warning)

the workflow is the same little idea it always was: cursor on a symbol, open the picker, see where this thing is defined and used, jump. it just doesn't lie to you about how many usages there are anymore.

would love feedback, especially on the lsp + text merge. curious whether it pushes peeper from "a little lsp peeper" into "a worse version of one of the heavy hitters," or whether the focused single-purpose window could earn a place in your vimrc.

thanks

repo: https://github.com/parwest/peeper-picker.nvim