okooooooo/pebrel
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2cac13b35b251494de55f509b30a2fb2b575f827
pebrel/extra/completions/pebrel.bash
T
AnxForever 70b90f1880 feat(gpui): open a folder in a chosen shell from the Explorer menu 
Right-clicking a folder has always opened the configured default shell —
usually PowerShell — with no way to ask for a WSL distribution instead.

- `--shell <id>` takes the same ids the `shell` setting uses (`pwsh`, `cmd`,
  `wsl:Ubuntu`, or an imported profile's settings id) and applies to the
  first tab this process creates. It carries an id rather than a path so
  every launch re-resolves the executable.
- The id travels both startup paths: the cold start (`run_shell` →
  `WorkspaceStartup::NewTerminal`), and the resident hand-off, which is the
  common case on Windows. `tab.new`/`window.create` gained an optional
  `shell` field, so clicking the menu while Pebrel is already running adds a
  tab to the existing window instead of starting a second process.
- An explicit request never silently degrades. An unresolvable id fails
  (`invalid_shell`, or a startup error before any window opens), and a
  `wsl:<distro>` id that the registry no longer lists still launches
  `wsl.exe -d <distro>`, leaving the complaint to the distribution itself.
  The `shell` setting keeps its documented fallback to the platform default.
- The winit shell rejects a shell request instead of ignoring it, so the
  caller falls back to a cold GPUI start and still gets the requested shell.

The resolution lives in a new `workspace::shell_launch` module: `main.rs` has
to validate `--shell` before it opens a window, and none of it needs
`NebulaWorkspace` state — `workspace.rs` is also at its line budget, which
this keeps from growing (`architecture/file-budgets.txt`).

The installer registers one context-menu entry per registered WSL
distribution (`PebrelWsl<n>`, skipping `docker-desktop*`) and the uninstaller
reclaims them by key prefix plus the command line it wrote. `--shell` is
passed before `--working-directory`: a drive-root `%V` ends in `\"`, which
would swallow the rest of the line if the directory came first. Both the
string and the order are pinned by installer assertions.

Docs (runtime API schema + control API) and shell completions are updated.
2026-09-14 23:07:38 +08:00

4055 lines
134 KiB
Bash
Raw Blame History

_pebrel() {
local i cur prev opts cmd
COMPREPLY=()
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
cur="$2"
else
cur="${COMP_WORDS[COMP_CWORD]}"
fi
prev="$3"
cmd=""
opts=""
for i in "${COMP_WORDS[@]:0:COMP_CWORD}"
do
case "${cmd},${i}" in
",$1")
cmd="pebrel"
;;
pebrel,agent)
cmd="pebrel__agent"
;;
pebrel,config)
cmd="pebrel__config"
;;
pebrel,ctl)
cmd="pebrel__ctl"
;;
pebrel,env)
cmd="pebrel__env"
;;
pebrel,help)
cmd="pebrel__help"
;;
pebrel,migrate)
cmd="pebrel__migrate"
;;
pebrel,pane)
cmd="pebrel__pane"
;;
pebrel,tab)
cmd="pebrel__tab"
;;
pebrel,window)
cmd="pebrel__window"
;;
pebrel__agent,delegate)
cmd="pebrel__agent__delegate"
;;
pebrel__agent,help)
cmd="pebrel__agent__help"
;;
pebrel__agent,list)
cmd="pebrel__agent__list"
;;
pebrel__agent,paste)
cmd="pebrel__agent__paste"
;;
pebrel__agent,read)
cmd="pebrel__agent__read"
;;
pebrel__agent,send)
cmd="pebrel__agent__send"
;;
pebrel__agent,wait)
cmd="pebrel__agent__wait"
;;
pebrel__agent__help,delegate)
cmd="pebrel__agent__help__delegate"
;;
pebrel__agent__help,help)
cmd="pebrel__agent__help__help"
;;
pebrel__agent__help,list)
cmd="pebrel__agent__help__list"
;;
pebrel__agent__help,paste)
cmd="pebrel__agent__help__paste"
;;
pebrel__agent__help,read)
cmd="pebrel__agent__help__read"
;;
pebrel__agent__help,send)
cmd="pebrel__agent__help__send"
;;
pebrel__agent__help,wait)
cmd="pebrel__agent__help__wait"
;;
pebrel__config,check)
cmd="pebrel__config__check"
;;
pebrel__config,help)
cmd="pebrel__config__help"
;;
pebrel__config,init)
cmd="pebrel__config__init"
;;
pebrel__config__help,check)
cmd="pebrel__config__help__check"
;;
pebrel__config__help,help)
cmd="pebrel__config__help__help"
;;
pebrel__config__help,init)
cmd="pebrel__config__help__init"
;;
pebrel__ctl,agent-fork)
cmd="pebrel__ctl__agent__fork"
;;
pebrel__ctl,agent-get)
cmd="pebrel__ctl__agent__get"
;;
pebrel__ctl,agent-paste)
cmd="pebrel__ctl__agent__paste"
;;
pebrel__ctl,agent-prompt)
cmd="pebrel__ctl__agent__prompt"
;;
pebrel__ctl,agent-read)
cmd="pebrel__ctl__agent__read"
;;
pebrel__ctl,agent-start)
cmd="pebrel__ctl__agent__start"
;;
pebrel__ctl,agent-wait)
cmd="pebrel__ctl__agent__wait"
;;
pebrel__ctl,agents)
cmd="pebrel__ctl__agents"
;;
pebrel__ctl,close-pane)
cmd="pebrel__ctl__close__pane"
;;
pebrel__ctl,close-tab)
cmd="pebrel__ctl__close__tab"
;;
pebrel__ctl,close-window)
cmd="pebrel__ctl__close__window"
;;
pebrel__ctl,describe)
cmd="pebrel__ctl__describe"
;;
pebrel__ctl,exec-pane)
cmd="pebrel__ctl__exec__pane"
;;
pebrel__ctl,focus)
cmd="pebrel__ctl__focus"
;;
pebrel__ctl,help)
cmd="pebrel__ctl__help"
;;
pebrel__ctl,move-tab)
cmd="pebrel__ctl__move__tab"
;;
pebrel__ctl,new-tab)
cmd="pebrel__ctl__new__tab"
;;
pebrel__ctl,new-window)
cmd="pebrel__ctl__new__window"
;;
pebrel__ctl,orchestrate)
cmd="pebrel__ctl__orchestrate"
;;
pebrel__ctl,paste)
cmd="pebrel__ctl__paste"
;;
pebrel__ctl,procs)
cmd="pebrel__ctl__procs"
;;
pebrel__ctl,prompt)
cmd="pebrel__ctl__prompt"
;;
pebrel__ctl,read)
cmd="pebrel__ctl__read"
;;
pebrel__ctl,rename-tab)
cmd="pebrel__ctl__rename__tab"
;;
pebrel__ctl,resize-pane)
cmd="pebrel__ctl__resize__pane"
;;
pebrel__ctl,run)
cmd="pebrel__ctl__run"
;;
pebrel__ctl,send-key)
cmd="pebrel__ctl__send__key"
;;
pebrel__ctl,snapshot)
cmd="pebrel__ctl__snapshot"
;;
pebrel__ctl,split)
cmd="pebrel__ctl__split"
;;
pebrel__ctl,subscribe)
cmd="pebrel__ctl__subscribe"
;;
pebrel__ctl,wait)
cmd="pebrel__ctl__wait"
;;
pebrel__ctl,zoom-pane)
cmd="pebrel__ctl__zoom__pane"
;;
pebrel__ctl__help,agent-fork)
cmd="pebrel__ctl__help__agent__fork"
;;
pebrel__ctl__help,agent-get)
cmd="pebrel__ctl__help__agent__get"
;;
pebrel__ctl__help,agent-paste)
cmd="pebrel__ctl__help__agent__paste"
;;
pebrel__ctl__help,agent-prompt)
cmd="pebrel__ctl__help__agent__prompt"
;;
pebrel__ctl__help,agent-read)
cmd="pebrel__ctl__help__agent__read"
;;
pebrel__ctl__help,agent-start)
cmd="pebrel__ctl__help__agent__start"
;;
pebrel__ctl__help,agent-wait)
cmd="pebrel__ctl__help__agent__wait"
;;
pebrel__ctl__help,agents)
cmd="pebrel__ctl__help__agents"
;;
pebrel__ctl__help,close-pane)
cmd="pebrel__ctl__help__close__pane"
;;
pebrel__ctl__help,close-tab)
cmd="pebrel__ctl__help__close__tab"
;;
pebrel__ctl__help,close-window)
cmd="pebrel__ctl__help__close__window"
;;
pebrel__ctl__help,describe)
cmd="pebrel__ctl__help__describe"
;;
pebrel__ctl__help,exec-pane)
cmd="pebrel__ctl__help__exec__pane"
;;
pebrel__ctl__help,focus)
cmd="pebrel__ctl__help__focus"
;;
pebrel__ctl__help,help)
cmd="pebrel__ctl__help__help"
;;
pebrel__ctl__help,move-tab)
cmd="pebrel__ctl__help__move__tab"
;;
pebrel__ctl__help,new-tab)
cmd="pebrel__ctl__help__new__tab"
;;
pebrel__ctl__help,new-window)
cmd="pebrel__ctl__help__new__window"
;;
pebrel__ctl__help,orchestrate)
cmd="pebrel__ctl__help__orchestrate"
;;
pebrel__ctl__help,paste)
cmd="pebrel__ctl__help__paste"
;;
pebrel__ctl__help,procs)
cmd="pebrel__ctl__help__procs"
;;
pebrel__ctl__help,prompt)
cmd="pebrel__ctl__help__prompt"
;;
pebrel__ctl__help,read)
cmd="pebrel__ctl__help__read"
;;
pebrel__ctl__help,rename-tab)
cmd="pebrel__ctl__help__rename__tab"
;;
pebrel__ctl__help,resize-pane)
cmd="pebrel__ctl__help__resize__pane"
;;
pebrel__ctl__help,run)
cmd="pebrel__ctl__help__run"
;;
pebrel__ctl__help,send-key)
cmd="pebrel__ctl__help__send__key"
;;
pebrel__ctl__help,snapshot)
cmd="pebrel__ctl__help__snapshot"
;;
pebrel__ctl__help,split)
cmd="pebrel__ctl__help__split"
;;
pebrel__ctl__help,subscribe)
cmd="pebrel__ctl__help__subscribe"
;;
pebrel__ctl__help,wait)
cmd="pebrel__ctl__help__wait"
;;
pebrel__ctl__help,zoom-pane)
cmd="pebrel__ctl__help__zoom__pane"
;;
pebrel__help,agent)
cmd="pebrel__help__agent"
;;
pebrel__help,config)
cmd="pebrel__help__config"
;;
pebrel__help,ctl)
cmd="pebrel__help__ctl"
;;
pebrel__help,env)
cmd="pebrel__help__env"
;;
pebrel__help,help)
cmd="pebrel__help__help"
;;
pebrel__help,migrate)
cmd="pebrel__help__migrate"
;;
pebrel__help,pane)
cmd="pebrel__help__pane"
;;
pebrel__help,tab)
cmd="pebrel__help__tab"
;;
pebrel__help,window)
cmd="pebrel__help__window"
;;
pebrel__help__agent,delegate)
cmd="pebrel__help__agent__delegate"
;;
pebrel__help__agent,list)
cmd="pebrel__help__agent__list"
;;
pebrel__help__agent,paste)
cmd="pebrel__help__agent__paste"
;;
pebrel__help__agent,read)
cmd="pebrel__help__agent__read"
;;
pebrel__help__agent,send)
cmd="pebrel__help__agent__send"
;;
pebrel__help__agent,wait)
cmd="pebrel__help__agent__wait"
;;
pebrel__help__config,check)
cmd="pebrel__help__config__check"
;;
pebrel__help__config,init)
cmd="pebrel__help__config__init"
;;
pebrel__help__ctl,agent-fork)
cmd="pebrel__help__ctl__agent__fork"
;;
pebrel__help__ctl,agent-get)
cmd="pebrel__help__ctl__agent__get"
;;
pebrel__help__ctl,agent-paste)
cmd="pebrel__help__ctl__agent__paste"
;;
pebrel__help__ctl,agent-prompt)
cmd="pebrel__help__ctl__agent__prompt"
;;
pebrel__help__ctl,agent-read)
cmd="pebrel__help__ctl__agent__read"
;;
pebrel__help__ctl,agent-start)
cmd="pebrel__help__ctl__agent__start"
;;
pebrel__help__ctl,agent-wait)
cmd="pebrel__help__ctl__agent__wait"
;;
pebrel__help__ctl,agents)
cmd="pebrel__help__ctl__agents"
;;
pebrel__help__ctl,close-pane)
cmd="pebrel__help__ctl__close__pane"
;;
pebrel__help__ctl,close-tab)
cmd="pebrel__help__ctl__close__tab"
;;
pebrel__help__ctl,close-window)
cmd="pebrel__help__ctl__close__window"
;;
pebrel__help__ctl,describe)
cmd="pebrel__help__ctl__describe"
;;
pebrel__help__ctl,exec-pane)
cmd="pebrel__help__ctl__exec__pane"
;;
pebrel__help__ctl,focus)
cmd="pebrel__help__ctl__focus"
;;
pebrel__help__ctl,move-tab)
cmd="pebrel__help__ctl__move__tab"
;;
pebrel__help__ctl,new-tab)
cmd="pebrel__help__ctl__new__tab"
;;
pebrel__help__ctl,new-window)
cmd="pebrel__help__ctl__new__window"
;;
pebrel__help__ctl,orchestrate)
cmd="pebrel__help__ctl__orchestrate"
;;
pebrel__help__ctl,paste)
cmd="pebrel__help__ctl__paste"
;;
pebrel__help__ctl,procs)
cmd="pebrel__help__ctl__procs"
;;
pebrel__help__ctl,prompt)
cmd="pebrel__help__ctl__prompt"
;;
pebrel__help__ctl,read)
cmd="pebrel__help__ctl__read"
;;
pebrel__help__ctl,rename-tab)
cmd="pebrel__help__ctl__rename__tab"
;;
pebrel__help__ctl,resize-pane)
cmd="pebrel__help__ctl__resize__pane"
;;
pebrel__help__ctl,run)
cmd="pebrel__help__ctl__run"
;;
pebrel__help__ctl,send-key)
cmd="pebrel__help__ctl__send__key"
;;
pebrel__help__ctl,snapshot)
cmd="pebrel__help__ctl__snapshot"
;;
pebrel__help__ctl,split)
cmd="pebrel__help__ctl__split"
;;
pebrel__help__ctl,subscribe)
cmd="pebrel__help__ctl__subscribe"
;;
pebrel__help__ctl,wait)
cmd="pebrel__help__ctl__wait"
;;
pebrel__help__ctl,zoom-pane)
cmd="pebrel__help__ctl__zoom__pane"
;;
pebrel__help__pane,close)
cmd="pebrel__help__pane__close"
;;
pebrel__help__pane,exec)
cmd="pebrel__help__pane__exec"
;;
pebrel__help__pane,list)
cmd="pebrel__help__pane__list"
;;
pebrel__help__pane,paste)
cmd="pebrel__help__pane__paste"
;;
pebrel__help__pane,read)
cmd="pebrel__help__pane__read"
;;
pebrel__help__pane,resize)
cmd="pebrel__help__pane__resize"
;;
pebrel__help__pane,send)
cmd="pebrel__help__pane__send"
;;
pebrel__help__pane,wait)
cmd="pebrel__help__pane__wait"
;;
pebrel__help__pane,zoom)
cmd="pebrel__help__pane__zoom"
;;
pebrel__help__tab,close)
cmd="pebrel__help__tab__close"
;;
pebrel__help__tab,move)
cmd="pebrel__help__tab__move"
;;
pebrel__help__tab,rename)
cmd="pebrel__help__tab__rename"
;;
pebrel__help__window,close)
cmd="pebrel__help__window__close"
;;
pebrel__pane,close)
cmd="pebrel__pane__close"
;;
pebrel__pane,exec)
cmd="pebrel__pane__exec"
;;
pebrel__pane,help)
cmd="pebrel__pane__help"
;;
pebrel__pane,list)
cmd="pebrel__pane__list"
;;
pebrel__pane,paste)
cmd="pebrel__pane__paste"
;;
pebrel__pane,read)
cmd="pebrel__pane__read"
;;
pebrel__pane,resize)
cmd="pebrel__pane__resize"
;;
pebrel__pane,send)
cmd="pebrel__pane__send"
;;
pebrel__pane,wait)
cmd="pebrel__pane__wait"
;;
pebrel__pane,zoom)
cmd="pebrel__pane__zoom"
;;
pebrel__pane__help,close)
cmd="pebrel__pane__help__close"
;;
pebrel__pane__help,exec)
cmd="pebrel__pane__help__exec"
;;
pebrel__pane__help,help)
cmd="pebrel__pane__help__help"
;;
pebrel__pane__help,list)
cmd="pebrel__pane__help__list"
;;
pebrel__pane__help,paste)
cmd="pebrel__pane__help__paste"
;;
pebrel__pane__help,read)
cmd="pebrel__pane__help__read"
;;
pebrel__pane__help,resize)
cmd="pebrel__pane__help__resize"
;;
pebrel__pane__help,send)
cmd="pebrel__pane__help__send"
;;
pebrel__pane__help,wait)
cmd="pebrel__pane__help__wait"
;;
pebrel__pane__help,zoom)
cmd="pebrel__pane__help__zoom"
;;
pebrel__tab,close)
cmd="pebrel__tab__close"
;;
pebrel__tab,help)
cmd="pebrel__tab__help"
;;
pebrel__tab,move)
cmd="pebrel__tab__move"
;;
pebrel__tab,rename)
cmd="pebrel__tab__rename"
;;
pebrel__tab__help,close)
cmd="pebrel__tab__help__close"
;;
pebrel__tab__help,help)
cmd="pebrel__tab__help__help"
;;
pebrel__tab__help,move)
cmd="pebrel__tab__help__move"
;;
pebrel__tab__help,rename)
cmd="pebrel__tab__help__rename"
;;
pebrel__window,close)
cmd="pebrel__window__close"
;;
pebrel__window,help)
cmd="pebrel__window__help"
;;
pebrel__window__help,close)
cmd="pebrel__window__help__close"
;;
pebrel__window__help,help)
cmd="pebrel__window__help__help"
;;
*)
;;
esac
done
case "${cmd}" in
pebrel)
opts="-q -v -e -T -o -h -V --print-events --ref-test --embed --gpui --config-file --socket --daemon --working-directory --shell --hold --command --title --class --option --help --version ctl env window tab pane agent migrate config help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--embed)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--config-file)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
--socket)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
--working-directory)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
--shell)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--command)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
-e)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--title)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
-T)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--class)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--option)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
-o)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent)
opts="-h --help list send delegate paste read wait help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__delegate)
opts="-h --generation --pretty --timeout-ms --help <AGENT> <TEXT>..."
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help)
opts="list send delegate paste read wait help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help__delegate)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help__help)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help__list)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help__send)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__help__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__list)
opts="-h --pretty --window --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__paste)
opts="-h --stdin --from-file --no-submit --wait --wait-timeout-ms --generation --pretty --timeout-ms --help <AGENT> [TEXT]..."
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--from-file)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
--wait-timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__read)
opts="-h --lines --generation --pretty --timeout-ms --help <AGENT>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--lines)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__send)
opts="-h --no-submit --wait --wait-timeout-ms --generation --pretty --timeout-ms --help <AGENT> <TEXT>..."
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--wait-timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__agent__wait)
opts="-h --state --after-seq --generation --pretty --timeout-ms --help <AGENT>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--state)
COMPREPLY=($(compgen -W "idle running waiting-input attention finished failed settled" -- "${cur}"))
return 0
;;
--after-seq)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__config)
opts="-h --help check init help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__config__check)
opts="-h --config-file --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--config-file)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__config__help)
opts="check init help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__config__help__check)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__config__help__help)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__config__help__init)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__config__init)
opts="-h --config-file --language --force --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--config-file)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
--language)
COMPREPLY=($(compgen -W "system zh-CN en-US" -- "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl)
opts="-h --pretty --timeout-ms --help describe snapshot orchestrate agents agent-start agent-fork agent-get agent-prompt agent-paste agent-read agent-wait subscribe new-window close-window focus new-tab close-tab rename-tab move-tab split close-pane zoom-pane resize-pane prompt paste read procs send-key run exec-pane wait help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agent__fork)
opts="-h --window --source-pane --source-cwd --name --kind --resume-session-id --branch --base --path --allow-dirty-source --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--source-pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--source-cwd)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--name)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--kind)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--resume-session-id)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--branch)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--base)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--path)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agent__get)
opts="-h --agent --generation --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--agent)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agent__paste)
opts="-h --agent --generation --text --no-submit --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--agent)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--text)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agent__prompt)
opts="-h --agent --generation --text --no-submit --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--agent)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--text)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agent__read)
opts="-h --agent --generation --lines --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--agent)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--lines)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agent__start)
opts="-h --window --name --kind --cwd --resume-session-id --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--name)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--kind)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--cwd)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--resume-session-id)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agent__wait)
opts="-h --agent --generation --state --after-seq --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--agent)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--generation)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--state)
COMPREPLY=($(compgen -W "idle running waiting-input attention finished failed settled" -- "${cur}"))
return 0
;;
--after-seq)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__agents)
opts="-h --window --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__close__pane)
opts="-h --window --pane --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__close__tab)
opts="-h --window --tab --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--tab)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__close__window)
opts="-h --window --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__describe)
opts="-h --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__exec__pane)
opts="-h --window --pane --max-output-bytes --pretty --timeout-ms --help <ARGV>..."
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--max-output-bytes)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__focus)
opts="-h --window --pane --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help)
opts="describe snapshot orchestrate agents agent-start agent-fork agent-get agent-prompt agent-paste agent-read agent-wait subscribe new-window close-window focus new-tab close-tab rename-tab move-tab split close-pane zoom-pane resize-pane prompt paste read procs send-key run exec-pane wait help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agent__fork)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agent__get)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agent__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agent__prompt)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agent__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agent__start)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agent__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__agents)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__close__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__close__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__close__window)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__describe)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__exec__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__focus)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__help)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__move__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__new__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__new__window)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__orchestrate)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__procs)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__prompt)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__rename__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__resize__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__run)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__send__key)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__snapshot)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__split)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__subscribe)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__help__zoom__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__move__tab)
opts="-h --window --tab --to --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--tab)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--to)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__new__tab)
opts="-h --window --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__new__window)
opts="-h --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__orchestrate)
opts="-h --spec --file --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--spec)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--file)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__paste)
opts="-h --window --pane --text --no-submit --wait --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--text)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--wait)
COMPREPLY=($(compgen -W "idle running waiting-input attention finished failed settled" -- "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__procs)
opts="-h --window --pane --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__prompt)
opts="-h --window --pane --text --no-submit --wait --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--text)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--wait)
COMPREPLY=($(compgen -W "idle running waiting-input attention finished failed settled" -- "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__read)
opts="-h --window --pane --lines --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--lines)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__rename__tab)
opts="-h --window --tab --name --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--tab)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--name)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__resize__pane)
opts="-h --window --pane --ratio --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--ratio)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__run)
opts="-h --window --pane --command --no-wait --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--command)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__send__key)
opts="-h --window --pane --key --shift --alt --control --repeat --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--key)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--repeat)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__snapshot)
opts="-h --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__split)
opts="-h --window --pane --direction --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--direction)
COMPREPLY=($(compgen -W "right down" -- "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__subscribe)
opts="-h --since --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--since)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__wait)
opts="-h --window --pane --state --after-seq --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--state)
COMPREPLY=($(compgen -W "idle running waiting-input attention finished failed settled" -- "${cur}"))
return 0
;;
--after-seq)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__ctl__zoom__pane)
opts="-h --window --pane --zoomed --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--pane)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--zoomed)
COMPREPLY=($(compgen -W "true false" -- "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__env)
opts="-h --pretty --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help)
opts="ctl env window tab pane agent migrate config help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__agent)
opts="list send delegate paste read wait"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__agent__delegate)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__agent__list)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__agent__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__agent__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__agent__send)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__agent__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__config)
opts="check init"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__config__check)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__config__init)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl)
opts="describe snapshot orchestrate agents agent-start agent-fork agent-get agent-prompt agent-paste agent-read agent-wait subscribe new-window close-window focus new-tab close-tab rename-tab move-tab split close-pane zoom-pane resize-pane prompt paste read procs send-key run exec-pane wait"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agent__fork)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agent__get)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agent__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agent__prompt)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agent__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agent__start)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agent__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__agents)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__close__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__close__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__close__window)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__describe)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__exec__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__focus)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__move__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__new__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__new__window)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__orchestrate)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__procs)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__prompt)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__rename__tab)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__resize__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__run)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__send__key)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__snapshot)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__split)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__subscribe)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__ctl__zoom__pane)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__env)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__help)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__migrate)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane)
opts="list read send paste wait exec close zoom resize"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__close)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__exec)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__list)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__resize)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__send)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__pane__zoom)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__tab)
opts="close rename move"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__tab__close)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__tab__move)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__tab__rename)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__window)
opts="close"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__help__window__close)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__migrate)
opts="-c -d -i -s -h --config-file --dry-run --skip-imports --skip-renames --silent --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--config-file)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
-c)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane)
opts="-h --help list read send paste wait exec close zoom resize help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__close)
opts="-h --window --pretty --timeout-ms --help <PANE>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__exec)
opts="-h --window --max-output-bytes --pretty --timeout-ms --help <PANE> <ARGV>..."
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--max-output-bytes)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help)
opts="list read send paste wait exec close zoom resize help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__close)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__exec)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__help)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__list)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__paste)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__read)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__resize)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__send)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__wait)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__help__zoom)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__list)
opts="-h --pretty --window --timeout-ms --help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__paste)
opts="-h --stdin --from-file --no-submit --wait --wait-timeout-ms --window --pretty --timeout-ms --help <PANE> [TEXT]..."
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--from-file)
local oldifs
if [ -n "${IFS+x}" ]; then
oldifs="$IFS"
fi
IFS=$'\n'
COMPREPLY=($(compgen -f "${cur}"))
if [ -n "${oldifs+x}" ]; then
IFS="$oldifs"
fi
if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
compopt -o filenames
fi
return 0
;;
--wait-timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__read)
opts="-h --lines --window --pretty --timeout-ms --help <PANE>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--lines)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__resize)
opts="-h --window --pretty --timeout-ms --help <PANE> <RATIO>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__send)
opts="-h --no-submit --wait --wait-timeout-ms --window --pretty --timeout-ms --help <PANE> <TEXT>..."
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--wait-timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__wait)
opts="-h --state --after-seq --window --pretty --timeout-ms --help <PANE>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--state)
COMPREPLY=($(compgen -W "idle running waiting-input attention finished failed settled" -- "${cur}"))
return 0
;;
--after-seq)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__pane__zoom)
opts="-h --zoomed --window --pretty --timeout-ms --help <PANE>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--zoomed)
COMPREPLY=($(compgen -W "true false" -- "${cur}"))
return 0
;;
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab)
opts="-h --help close rename move help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__close)
opts="-h --window --pretty --timeout-ms --help <TAB>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__help)
opts="close rename move help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__help__close)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__help__help)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__help__move)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__help__rename)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__move)
opts="-h --window --pretty --timeout-ms --help <TAB> <TO>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__tab__rename)
opts="-h --window --pretty --timeout-ms --help <TAB> <NAME>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--window)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__window)
opts="-h --help close help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__window__close)
opts="-h --pretty --timeout-ms --help <WINDOW>"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
--timeout-ms)
COMPREPLY=($(compgen -f "${cur}"))
return 0
;;
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__window__help)
opts="close help"
if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__window__help__close)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
pebrel__window__help__help)
opts=""
if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
fi
case "${prev}" in
*)
COMPREPLY=()
;;
esac
COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
return 0
;;
esac
}
if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
complete -F _pebrel -o nosort -o bashdefault -o default pebrel
else
complete -F _pebrel -o bashdefault -o default pebrel
fi
Reference in new issue View Git Blame Copy Permalink