Fuzzy Filter lines in files ( helm-swoop )

[mkcode]

Inspired by @baldwindavid in #22581. And following up on the telescope feature request #8279.

I'm sharing 2 tasks I created that both use a combination of fzf and bat. These both work well enough for me in place of a built in telescope in zed.

Swoop is essentially, fuzzy filtering the lines in a file and jumping to it. The name and pattern is inspired by an emacs package - helm-swoop - that I started using over a decade ago. I find the pattern to be more intuitive and faster in general than searching in most cases. This pattern may also go a long way to scratch the itch for the people (myself included) that want either #4930 or #14801. I use the builtin vim sneak functionality for precise movement to the beginning of a word on screen, and then this swoop pattern for larger motions in a file.

In this demo, the first commands are swoop, and the latter are find files.

EDIT: I completely updated this. Swoop now goes directly to the beginning of the word, and file previews are improved. It also now properly supports selected text as the initial input.

These require the following script to be available in your PATH:

fzf-bat-preview

Ensure this in script is available in your PATH. I put this in: ~/.local/bin/fzf-bat-preview

#!/usr/bin/env bash
# fzf-bat-preview: Preview a file around a single line or a line range using bat.
# Usage:
#   fzf-bat-preview <file> <line|start-end>
# Env:
#   FZF_PREVIEW_CONTEXT (default: 10) - number of context lines around the hit
#   BAT_CMD (optional) - override the bat binary (e.g., "batcat")

set -euo pipefail

CONTEXT_RAW="${FZF_PREVIEW_CONTEXT:-10}"
# Ensure CONTEXT is numeric; fallback to 10 otherwise
if [[ "${CONTEXT_RAW}" =~ ^[0-9]+$ ]]; then
  CONTEXT="${CONTEXT_RAW}"
else
  CONTEXT=10
fi

FILE_IN="${1:-}"
LINE_SPEC_IN="${2:-}"

# Single variable for bat command
BAT="${BAT_CMD:-bat} --theme=TwoDark --color=always --paging=never --style numbers"

# --- helpers ---
strip_ansi() {
  # Remove ANSI escape sequences (CSI/SGR, etc.)
  sed -E 's/\x1B\[[0-9;]*[[:alpha:]]//g'
}
trim() {
  sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//'
}

# --- sanitize inputs ---
FILE="$(printf '%s' "${FILE_IN}" | strip_ansi | trim)"
LINE_SPEC_RAW="$(printf '%s' "${LINE_SPEC_IN}" | strip_ansi | trim)"

# If no file provided, nothing to preview
if [[ -z "${FILE}" || ! -e "${FILE}" ]]; then
  echo "No file or file not found: ${FILE}" >&2
  exit 0
fi

# If no line spec, just show the file
if [[ -z "${LINE_SPEC_RAW}" ]]; then
  # shellcheck disable=SC2086
  exec ${BAT} -- "${FILE}"
fi

# Extract up to two integers from the line spec robustly (no mapfile needed)
NUMS_STR="$(printf '%s\n' "${LINE_SPEC_RAW}" |
  tr -c '0-9' ' ' |
  awk '{for(i=1;i<=NF;i++) if($i!="") print $i}' |
  head -n2 |
  paste -sd' ' -)"

if [[ -z "${NUMS_STR}" ]]; then
  # shellcheck disable=SC2086
  exec ${BAT} -- "${FILE}"
fi

# Parse into START/END
set -- ${NUMS_STR}
START_HIT="${1:-}"
END_HIT="${2:-${1:-}}"

# Validate numeric
if ! [[ "${START_HIT}" =~ ^[0-9]+$ ]]; then
  # shellcheck disable=SC2086
  exec ${BAT} -- "${FILE}"
fi
if ! [[ "${END_HIT}" =~ ^[0-9]+$ ]]; then
  END_HIT="${START_HIT}"
fi

# Normalize and clamp to >= 1
((START_HIT < 1)) && START_HIT=1
((END_HIT < 1)) && END_HIT=1
if ((END_HIT < START_HIT)); then
  tmp="${START_HIT}"
  START_HIT="${END_HIT}"
  END_HIT="${tmp}"
fi

# Determine max lines in file (digits only)
MAX_LINE=0
if [[ -r "${FILE}" ]]; then
  MAX_LINE="$(wc -l <"${FILE}" 2>/dev/null | tr -cd '0-9')"
  [[ -z "${MAX_LINE}" ]] && MAX_LINE=0
fi

# If file appears empty or unknown length, just show the file (avoid invalid ranges)
if ((MAX_LINE == 0)); then
  # shellcheck disable=SC2086
  exec ${BAT} -- "${FILE}"
fi

# Initial preview range (unclamped)
PREVIEW_START=$((START_HIT - CONTEXT))
PREVIEW_END=$((END_HIT + CONTEXT))

# Desired total height of the preview window
DESIRED=$(((END_HIT - START_HIT + 1) + 2 * CONTEXT))

# Adjust for top bound
if ((PREVIEW_START < 1)); then
  MISSING_TOP=$((1 - PREVIEW_START))
  PREVIEW_START=1
  PREVIEW_END=$((PREVIEW_END + MISSING_TOP))
fi

# Adjust for bottom bound
if ((PREVIEW_END > MAX_LINE)); then
  MISSING_BOTTOM=$((PREVIEW_END - MAX_LINE))
  PREVIEW_END=${MAX_LINE}
  PREVIEW_START=$((PREVIEW_START - MISSING_BOTTOM))
  ((PREVIEW_START < 1)) && PREVIEW_START=1
fi

# If we still don't meet desired height, try to fill from both sides
ACTUAL=$((PREVIEW_END - PREVIEW_START + 1))
if ((ACTUAL < DESIRED)); then
  EXTRA=$((DESIRED - ACTUAL))
  # Take from the top if there's room
  if ((PREVIEW_START > 1)); then
    TAKE=$((PREVIEW_START - 1))
    ((TAKE > EXTRA)) && TAKE=${EXTRA}
    PREVIEW_START=$((PREVIEW_START - TAKE))
    EXTRA=$((EXTRA - TAKE))
  fi
  # Take from the bottom if there's room
  if ((EXTRA > 0 && PREVIEW_END < MAX_LINE)); then
    ROOM=$((MAX_LINE - PREVIEW_END))
    ((ROOM > EXTRA)) && ROOM=${EXTRA}
    PREVIEW_END=$((PREVIEW_END + ROOM))
  fi
fi

# Final safety clamp and ensure non-empty range
((PREVIEW_START < 1)) && PREVIEW_START=1
((PREVIEW_END < PREVIEW_START)) && PREVIEW_END=${PREVIEW_START}

# Build highlight arguments for the whole range, clamped to file length
HL_ARGS=()
START_CLAMP=$((START_HIT < 1 ? 1 : START_HIT))
END_CLAMP=$((END_HIT > MAX_LINE ? MAX_LINE : END_HIT))
for ((i = START_CLAMP; i <= END_CLAMP; i++)); do
  HL_ARGS+=(--highlight-line "${i}")
done

# Render with bat
# shellcheck disable=SC2086
exec ${BAT} --line-range "${PREVIEW_START}:${PREVIEW_END}" \
  "${HL_ARGS[@]}" \
  -- "${FILE}"

Here is the tasks.json. Take any one or all 3 of these related tasks.

  {
    "label": "swoop",
    "env": {
      "RG_PREFIX": "rg --column --line-number --no-heading --color=always --smart-case"
    },
    "command": "fzf --ansi --disabled --wrap --list-border=bottom --input-border=rounded --preview-border=rounded --header='\n' --info=inline-right --height=100% --prompt=\"$ZED_FILENAME > \" --border=rounded --border-label=\"Swoop\" --bind \"start:reload:${RG_PREFIX} {q} \"$ZED_FILE\"\" --bind \"change:reload:sleep 0.001; ${RG_PREFIX} {q} \"$ZED_FILE\" || true\" --delimiter : --with-nth '1,3..' --preview \"FZF_PREVIEW_CONTEXT=10 echo && fzf-bat-preview \"$ZED_FILE\" {1}\" --preview-window='down,50%,noinfo' --preview-label=\"$ZED_FILENAME\" --bind 'enter:become(zed \"$ZED_FILE\":{1}:{2})' --query ${ZED_SELECTED_TEXT:\"\"}",
    "use_new_terminal": true,
    "allow_concurrent_runs": true,
    "reveal": "always",
    "hide": "always",
    "shell": { "program": "sh" }
  },
  {
    "label": "find file",
    "command": "( rg --files --hidden --follow --glob '!.git/*'; rg --files --hidden --no-ignore --glob '*.env*' ) | fzf --ansi --border-label=\"find file\" --no-scrollbar --border=rounded --wrap --preview-window='down,50%,noinfo' --preview 'echo && bat --style=numbers --theme=TwoDark --color=always --line-range=:50 {}' --height=100% --header=\"\n\" --margin=1 --list-border=bottom --bind 'result:transform-preview-label:echo {1}' --bind 'focus:transform-preview-label:echo {1}' --bind 'enter:become(zed {1})' --reverse --input-border=rounded --info=inline-right",
    "use_new_terminal": true,
    "allow_concurrent_runs": true,
    "reveal": "always",
    "hide": "always",
    "shell": { "program": "sh" }
  },
  {
    "label": "search",
    "env": {
      "RG_PREFIX": "rg --column --line-number --no-heading --color=always --smart-case --hidden -g '!.git/**'"
    },
    "command": "fzf --ansi --disabled --border=rounded --no-scrollbar --border-label=\"Search in project\" --input-border=rounded --info=inline-right --wrap --height=100% --list-border=bottom --header=\"\n\" --bind \"start:reload:${RG_PREFIX} {q}\" --bind \"change:reload:sleep 0.001; ${RG_PREFIX} {q} || true\" --delimiter : --with-nth '1,4..' --preview-window='down,50%,noinfo' --preview-label-pos=0,top --preview \"echo && fzf-bat-preview {1} {2}\" --bind 'result:transform-preview-label:echo {1}' --bind 'focus:transform-preview-label:echo {1}' --bind 'enter:become(zed {1}:{2}:{3})' --query ${ZED_SELECTED_TEXT:\"\"}",
    "use_new_terminal": true,
    "allow_concurrent_runs": true,
    "reveal": "always",
    "hide": "always",
    "shell": { "program": "sh" }
  },

And keymap.json

      "space s s": [
        "task::Spawn",
        { "task_name": "swoop", "reveal_target": "center" }
      ],
      "space f f": [
        "task::Spawn",
        { "task_name": "find file", "reveal_target": "dock" }
      ],
      "space /": [
        "task::Spawn",
        { "task_name": "search", "reveal_target": "dock" }
      ],

Some tips that I've found related to this:

1. The "reveal_target": "center" works well for an in-window display and "reveal_target": "dock" works well for the entire window. Conceptually, for in file scoped operations and project scoped operations respectively. This is demoed in the video above.
2. I found that using sh as the shell program makes for faster startup time and minimal latency when using these commands.

Open to feedback, improvements and discussion. Hope this helps someone!

Original config for reference

Here is the tasks.json

  {
    "label": "swoop",
    "command": "bat --style=numbers --color=always --theme=TwoDark --paging=never $ZED_FILE | fzf --ansi --tiebreak=index --layout=reverse --input-border=rounded --info=inline-right --height=100% --border=rounded --margin=4 --color=bg+:#262930 --header=\"\n\" --prompt=\"$ZED_FILENAME > \" | awk '{print $1}' | xargs -I{} zed $ZED_FILE:{}",
    "use_new_terminal": true,
    "allow_concurrent_runs": true,
    "reveal": "always",
    "hide": "always",
    "shell": { "program": "sh" }
  },
  {
    "label": "find file",
    "command": "fzf --preview 'bat --style=numbers --theme=TwoDark --color=always --line-range=:100 {}' --height=100% --header=\"\n\" --margin=4 --reverse --input-border=rounded --info=inline-right | xargs -I{} zed {}",
    "use_new_terminal": true,
    "allow_concurrent_runs": true,
    "reveal": "always",
    "hide": "always",
    "shell": { "program": "sh" }
  }

And keymap.json

      "space s s": [
        "task::Spawn",
        { "task_name": "swoop", "reveal_target": "center" }
      ],
      "space f f": [
        "task::Spawn",
        { "task_name": "find file", "reveal_target": "dock" }
      ],

[overby-me]

For the interested, achieving the swoop feature with Television (and Nushell):

	{
		"label": "Find in File",
		"command": "bat --style=numbers --color=always --theme=TwoDark --paging=never $env.ZED_FILE | tv --ansi --input-header=$\"($env.ZED_RELATIVE_FILE)\" | ansi strip | str trim | split row \" \" | first | zeditor $\"($env.ZED_FILE):($in)\"",
		"hide": "always",
		"allow_concurrent_runs": true,
		"use_new_terminal": true,
		"shell": { "program": "nu" }
	}

[theherk]

This is super awesome; thank you. I find it useful to also have one that pipes from git ls-files so you only get repository files in the search.

  {
    "label": "find git files",
    "command": "git ls-files | fzf --multi --preview 'bat --color=always --line-range=:100 {}' --reverse --input-border=rounded --info=inline-right | xargs -I{} zed {}",
    "use_new_terminal": true,
    "allow_concurrent_runs": false,
    "reveal": "always",
    "hide": "always",
    "shell": { "program": "bash" }
  },

Also, I added --multi so you can select and open many files at once.

[mkcode]

Oooh, interesting. I never use this flow, but maybe I'll try it.

[mkcode]

I completely updated the original post. Swoop now goes directly to the beginning of the word, and file previews are improved. It also now properly supports selected text as the initial input.

[FloppyDisco]

@mkcode

thanks for posting this!

I originally found a feature like this in LiteXL. the 'go to line' action is a fuzzy search by line text, and I always really enjoyed that.
i though that this might be that at first but now that i am using it i see it's a bit different.

it is using ripgrep for the search so it is exact matches only.
why do you prefer this tool over just using the built in buffer search, since they both go by exact matches?

i managed to put a task together that uses fzf for fuzzy searching lines and i am very happy with how it works thanks for the inspiration!

#!/bin/sh

rg --line-number --color=always --colors 'match:none'  . "$ZED_FILE" | \
fzf \
    --query "$ZED_SELECTED_TEXT" \
    --ansi \
    --height=100% \
    --border=none \
    --info=inline-right \
    --delimiter : \
    --bind="enter:become(
        parse_column {q} {1}; 
    )"

# parse_column()

query="$1"
line="$2"
first="${query:0:1}"
text=$(sed -n "${line}p" "$ZED_FILE")
idx=1
for (( i=0; i<${#text}; i++ )); do
    if [[ "${text:$i:1}" == "$first" ]]; then
        idx=$(expr $i + 1)
        break
    fi
done
zed "$ZED_FILE:$line:$idx"

i couldn't get it working just writing the script in the task json. there were too many issues with quotations. so both of these have to be in your path to get this to work.
the twist here is that instead of just going to the start of the line. I took a bit of the idea from you that the cursor goes to the first char from the fzf search query. you can't match on the entire query because it's fuzzy but matching just the first char is pretty accurate most of the time.

[mkcode]

Thanks, @FloppyDisco. Glad you appreciate this!

why do you prefer this tool over just using the built in buffer search, since they both go by exact matches?

Easy. I prefer filtering and narrowing down rather than cycling through matches.

I just revisited this with your inspiration because what I had previously isn't exactly what I want. I want the direct filtering rather than having a separate previous preview window. But I also want the bat syntax highlighting, which is difficult because rg does not accept ANSI color codes.

So with the help of Opus 4.5, here's what I came up with, which I believe is a combination of both of our inputs.

Add swoop-open to the path. This goes for contiguous letter matches and falls back to the first column. I find that I usually type the beginnings of words, so I want more than just the first letter.

#!/usr/bin/env bash
# swoop-open: Open file at line and column based on query match
# Usage: swoop-open <file> <line_with_content> <query>
# Example: swoop-open myfile.py "  42  def hello():" "def"

FILE="$1"
LINE_CONTENT="$2"
QUERY="$3"

# Extract line number (first number in the string)
LINE=$(echo "$LINE_CONTENT" | awk '{ gsub(/[^0-9].*/, "", $1); print $1 }')

# Default column
COL=1

# Find column position of query in the actual file line
if [ -n "$QUERY" ] && [ -n "$LINE" ]; then
    ACTUAL_LINE=$(sed -n "${LINE}p" "$FILE")
    if [ -n "$ACTUAL_LINE" ]; then
        # Find position of query in line (1-indexed)
        POS=$(echo "$ACTUAL_LINE" | awk -v q="$QUERY" '{
            pos = index($0, q)
            print (pos > 0 ? pos : 1)
        }')
        if [ -n "$POS" ] && [ "$POS" -gt 0 ]; then
            COL=$POS
        fi
    fi
fi

# Open in Zed
exec zed "$FILE:$LINE:$COL"

And heres the task.json entry:

	{
		"label": "swoop",
		"command": "bat --style=numbers --color=always --theme=TwoDark --paging=never \"$ZED_FILE\" | fzf --ansi --layout=reverse --no-sort --nth=2.. --height=100% --border=rounded --border-label=\"Swoop\" --input-border=rounded --info=inline-right --header=\"\n\" --prompt=\"$ZED_FILENAME > \" --query \"${ZED_SELECTED_TEXT:-}\" --bind 'enter:become(swoop-open \"$ZED_FILE\" {} {q})'",
		"use_new_terminal": true,
		"allow_concurrent_runs": true,
		"reveal": "always",
		"hide": "always",
		"shell": { "program": "sh" }
	}

For me, this has it all. Colored syntax highlighting. Using the same window for intuitive narrowing. And moving the cursor to the correct column when selecting. Let me know if you prefer this as well.

[FloppyDisco]

hmm. i could not seem to get it working.
I do prefer the bat syntax highlighting though. i switched to rg because i couldn't reliably parse the line number from the output of fzf, but i was trying to do it with the fzf --delimiter i will probably switch mine over to using sed and bat for coloring because it looks so much better.

I may take a stab a updating the zed go to line action to allow searching by text as well. that would be the ideal solution for me. i really like the floating ui picker.

ok. so this new version you made DOES use fuzzy searching. but it will match on the whole first match of the query?

[mkcode]

Yes. It does use fuzzy searching to match on the line. But then non-fuzzy to jump to the correct column. I find I use ngram style beginning of words most of the time, so it works well for that pattern. More accurate than just first letter, but can fail on fuzzy matches in which case it will jump to column 1 on the line