Using fzf and jq to edit chezmoi managed files

[kartikdc]

I wrote this small zsh function that gets a list of chezmoi managed config files, uses jq to parse them and then passes them to fzf. Once selection is made from fzf it is passed as a parameter to chezmoi edit --apply. If a query is provided (eg. cfzf zshrc) and only there is only one match for it, it is automatically selected. I briefly tested it with bash and it seems to work fine.

# edit config files more easierly
cfzf () {
  fzf_command=("fzf")
  if [ -n "$1" ]; then
    fzf_command=($fzf_command "--query=$1" "-1")
  fi

  file_path=$( \
    chezmoi state dump | \
    jq -r '.entryState | with_entries(select(.value.type == "file")) | keys | .[]' | \
    ${fzf_command[@]} \
  )
  if [ -z "$file_path" ]; then
    >&2 echo "No file selected"
  else
    chezmoi edit --apply "$file_path"
  fi
}

Suggestions for improvement welcome.

[twpayne]

Nice! As an alternative to chezmoi state dump | jq ..., you can also get a list of files managed by chezmoi with the command:

$ chezmoi managed --include=files

[kartikdc]

Brilliant. I prefer this a lot more. Sheds the jq dependency too:

cfzf () {
  fzf_command=("fzf")
  if [ -n "$1" ]; then
    fzf_command=($fzf_command "--query=$1" "-1")
  fi

  file_path=$(chezmoi managed --include=files | ${fzf_command[@]})
  if [ -z "$file_path" ]; then
    >&2 echo "No file selected"
  else
    chezmoi edit --apply "$HOME/$file_path"
  fi
}

[PJC-64]

Just wondering if there's any particular reason why you wrote this as a bash function rather than a script?

I use fish as my command shell for a number of reasons, and just by modifying this to be a script (removing the function wrapper and adding the #!/bin/bash) this works for my simply by saving the new file into my ~/.local/bin without having to translate your code into fish at all.

[kartikdc]

No particular reason. I just prefer to manage shell hacks in the shell profile rather than as separate scripts which is a completely personal choice. Should be straigtforward to convert the function to an executable script as you noted.

[PJC-64]

Thanks for the info - that's great to know -- I'd made the changes and it appeared to be working for me, but always good to have confirmation there shouldn't be any issues hiding that could bite me later!

[Lockszmith-GH]

I have a similar solution, one that helps me manage a multi-layered chezmoi environment I've constructed for our team.
I posted a bit about it in #2574 and I'm getting our code ready to be sharable, so you can take it out for a ride.

At first I used grep with a hand-crafted regex to pick up 'best candidates' and if it was narrow enough, it would just open the editor with all the results.

Then I started using fzf in the cli, and replaced grep with fzf, in both non-interactive and interactive methods.
I call my script, vimy and it has the following features:

Usage:
vimy [file/query1 [file/query2 ... [file/queryN]]]

If not arguments are passed, fzf is launched with multi-select offering a selecting from the available chezmoi managed files.
For each argument:
- If the argument matches an existing path, it is added
- If the argument matches an existing relative path from $HOME, it is added.
- If the argument matches (using fzf --filter) exactly one entry, it is added.
- If nothing was added, then fzf is launched with the parameter as a --query argument

With the eventual list of files, nvim -p is then launched.

After the edit, the state is observed: if new files were specified, user is prompted, asking whether to add the new files to the chezmoi state.
User will also be prompted whether to add any modified files to the source state (aka. re-add)

This helps me not only find the files to edit quickly, but it helps me keep the managed state tidy.
The list of files contains everything that is relevant (files, scripts, templates and config).

Code

Since the code does a lot, and it's tied to my environment - I won't post all of it, but I'll share the fzf relevant parts.

_fzf_cmd is the 'shorthand' for the code to call, either interactively or non-interactively.

# Since we query this a lot, save the results into memory (maybe a temp file would be better here?)
valid_files="$({
    # All managed files
    chezmoi managed --include=files --path-style=absolute;
    # All scripts and templates from the source 
    chezmoi managed --include=scripts,templates --path-style=source-absolute
    chezmoi data --format json | jq -r .chezmoi.configFile
    } | sed "s|^$HOME/||" )"

function _fzf_cmd() {
    [[ -z "$(type -t fzf)" ]] && printf "%s\n" "${@}" && return

    local INTERACTIVE_QUERY=''
    local QUERY_PREFIX=''

    [[ "QUERY_TYPE" != "filter" ]] \
        && INTERACTIVE_QUERY="\
            --print-query --multi \
            --header='${HEADER}Select a file from your $CONTEXT chezmoi context...' \
            --preview-window=top --preview='head -$LINES $HOME/{}' \
        " \
        && QUERY_PREFIX='?'

    local QUERY=$(printf "'--${QUERY_TYPE:-query}=%s' " "${@}")
    local RESULTS=()
    # if QUERY=filter, this is not an interactive search.
    # if interactive search"
    #   gather results into RESULTS
    #   prefix first line with ? (this is the query text)
    #
    # if query ends with '!' exclamation symbol, only return query
    # (ommit the !)
    # if non-interactive and have results, remove query.
    #
    RESULTS=(${QUERY_PREFIX}$(eval "fzf ${INTERACTIVE_QUERY} \
        --no-sort --select-1 --exit-0 \
        $QUERY \
        " <<< "$valid_files" ))

    if [[ "${RESULTS[0]}" =~ \!^ ]]; then
        RESULTS="${RESULTS[0]%\!}"
    elif [[ "${QUERY_TYPE}" != "filter" && ${#RESULTS[@]} -gt 1 ]]; then
    # if not a filter search, remove query if results are returned.
        RESULTS=(${RESULTS[@]:1})
    fi
    printf '%s\n' "${RESULTS[@]}"
}

The key differences between my _fzf_cmd and @kartikdc solution, is the following:

• --print-query will return the query string. This allows me to parse this and provide a file-name that doesn't exist yet. (try ending the query with !.
• when called with QUERY_TYPE=filter, fzf is used as a fuzzy grep-like utility. (aka non-interactive)
• Query string will be prefixed with ?. (only interactive calls return the query string)
• Query is returned only if no matches were found, or the ! was specified.

[Lockszmith-GH]

Before fzf I had tab-completion for this as well, but I like fzf better, so will probably drop the tab completion.

[vicrdguez]

This is nice.

I'm thinking through building something similar to this, bur with some differences for how I use to edit my dotfiles:

Typically, I don't want to edit a single file for all of my dotfiles, but I want to edit the entire directory I started to manage with chezmoi add. One example is my neovim config, when I edit that one I want to open neovim in the .config/nvim directory, since very likely I would need to edit multiple files.

However I think there is no way to get from chezmoi the directories that were explicitly added, right? So I'll need to find a way to get the root folder of this type of dotfiles.

Any thoughts are welcomed!

[infused-kim]

Thank you all for sharing your chezmoi fzf scripts. It was super helpful.

Chezmoi has a plugin function that allows you to add custom commands.

I modified the script above to make it a plugin.

Simply put it in .local/bin/chezmoi-fzf:

#!/bin/bash

# Based on the script from:
# https://github.com/twpayne/chezmoi/discussions/2631#discussioncomment-4457933
cfzf () {
  file_path=$(chezmoi managed --include=files --exclude=externals | fzf --reverse --preview="cat {} | head -n 200" --query=$1)

  if [ -z "$file_path" ]; then
    >&2 echo "No file selected"
  else
    chezmoi edit --apply "$HOME/$file_path"
  fi
}

cfzf $1

And I also created .local/bin/chezmoi-gdiff:

#!/bin/bash

# Capture the output of chezmoi status
output=$(chezmoi status)

# Check if the output is empty
if [ -z "$output" ]; then
    echo "There are no differences."
else
    # Use the captured output for fzf
    echo "$output" | fzf --preview "chezmoi diff $HOME/{-1}"
fi

This makes it easier to browse the diff like this:

[twpayne]

This is really nice, thank you!