1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
|
# Include guard
if [[ ${__atuin_initialized-} == true ]]; then
false
elif [[ $- != *i* ]]; then
# Enable only in interactive shells
false
elif ((BASH_VERSINFO[0] < 3 || BASH_VERSINFO[0] == 3 && BASH_VERSINFO[1] < 1)); then
# Require bash >= 3.1
[[ -t 2 ]] && printf 'atuin: requires bash >= 3.1 for the integration.\n' >&2
false
else # (include guard) beginning of main content
#------------------------------------------------------------------------------
__atuin_initialized=true
ATUIN_SESSION=$(atuin uuid)
ATUIN_STTY=$(stty -g)
export ATUIN_SESSION
ATUIN_HISTORY_ID=""
__atuin_preexec() {
# Workaround for old versions of bash-preexec
if [[ ! ${BLE_ATTACHED-} ]]; then
# In older versions of bash-preexec, the preexec hook may be called
# even for the commands run by keybindings. There is no general and
# robust way to detect the command for keybindings, but at least we
# want to exclude Atuin's keybindings. When the preexec hook is called
# for a keybinding, the preexec hook for the user command will not
# fire, so we instead set a fake ATUIN_HISTORY_ID here to notify
# __atuin_precmd of this failure.
if [[ $BASH_COMMAND == '__atuin_history'* && $BASH_COMMAND != "$1" ]]; then
ATUIN_HISTORY_ID=__bash_preexec_failure__
return 0
fi
fi
local id
id=$(atuin history start -- "$1")
export ATUIN_HISTORY_ID=$id
__atuin_preexec_time=${EPOCHREALTIME-}
}
__atuin_precmd() {
local EXIT=$? __atuin_precmd_time=${EPOCHREALTIME-}
[[ ! $ATUIN_HISTORY_ID ]] && return
# If the previous preexec hook failed, we manually call __atuin_preexec
if [[ $ATUIN_HISTORY_ID == __bash_preexec_failure__ ]]; then
# This is the command extraction code taken from bash-preexec
local previous_command
previous_command=$(
export LC_ALL=C HISTTIMEFORMAT=''
builtin history 1 | sed '1 s/^ *[0-9][0-9]*[* ] //'
)
__atuin_preexec "$previous_command"
fi
local duration=""
# shellcheck disable=SC2154,SC2309
if [[ ${BLE_ATTACHED-} && ${_ble_exec_time_ata-} ]]; then
# With ble.sh, we utilize the shell variable `_ble_exec_time_ata`
# recorded by ble.sh. It is more accurate than the measurements by
# Atuin, which includes the spawn cost of Atuin. ble.sh uses the
# special shell variable `EPOCHREALTIME` in bash >= 5.0 with the
# microsecond resolution, or the builtin `time` in bash < 5.0 with the
# millisecond resolution.
duration=${_ble_exec_time_ata}000
elif ((BASH_VERSINFO[0] >= 5)); then
# We calculate the high-resolution duration based on EPOCHREALTIME
# (bash >= 5.0) recorded by precmd/preexec, though it might not be as
# accurate as `_ble_exec_time_ata` provided by ble.sh because it
# includes the extra time of the precmd/preexec handling. Since Bash
# does not offer floating-point arithmetic, we remove the non-digit
# characters and perform the integral arithmetic. The fraction part of
# EPOCHREALTIME is fixed to have 6 digits in Bash. We remove all the
# non-digit characters because the decimal point is not necessarily a
# period depending on the locale.
duration=$((${__atuin_precmd_time//[!0-9]} - ${__atuin_preexec_time//[!0-9]}))
if ((duration >= 0)); then
duration=${duration}000
else
duration="" # clear the result on overflow
fi
fi
(ATUIN_LOG=error atuin history end --exit "$EXIT" ${duration:+"--duration=$duration"} -- "$ATUIN_HISTORY_ID" &) >/dev/null 2>&1
export ATUIN_HISTORY_ID=""
}
__atuin_set_ret_value() {
return ${1:+"$1"}
}
# The shell function `__atuin_evaluate_prompt` evaluates prompt sequences in
# $PS1. We switch the implementation of the shell function
# `__atuin_evaluate_prompt` based on the Bash version because the expansion
# ${PS1@P} is only available in bash >= 4.4.
if ((BASH_VERSINFO[0] >= 5 || BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] >= 4)); then
__atuin_evaluate_prompt() {
__atuin_set_ret_value "${__bp_last_ret_value-}" "${__bp_last_argument_prev_command-}"
__atuin_prompt=${PS1@P}
# Note: Strip the control characters ^A (\001) and ^B (\002), which
# Bash internally uses to enclose the escape sequences. They are
# produced by '\[' and '\]', respectively, in $PS1 and used to tell
# Bash that the strings inbetween do not contribute to the prompt
# width. After the prompt width calculation, Bash strips those control
# characters before outputting it to the terminal. We here strip these
# characters following Bash's behavior.
__atuin_prompt=${__atuin_prompt//[$'\001\002']}
# Count the number of newlines contained in $__atuin_prompt
__atuin_prompt_offset=${__atuin_prompt//[!$'\n']}
__atuin_prompt_offset=${#__atuin_prompt_offset}
}
else
__atuin_evaluate_prompt() {
__atuin_prompt='$ '
__atuin_prompt_offset=0
}
fi
# The shell function `__atuin_clear_prompt N` outputs terminal control
# sequences to clear the contents of the current and N previous lines. After
# clearing, the cursor is placed at the beginning of the N-th previous line.
__atuin_clear_prompt_cache=()
__atuin_clear_prompt() {
local offset=$1
if [[ ! ${__atuin_clear_prompt_cache[offset]+set} ]]; then
if [[ ! ${__atuin_clear_prompt_cache[0]+set} ]]; then
__atuin_clear_prompt_cache[0]=$'\r'$(tput el 2>/dev/null || tput ce 2>/dev/null)
fi
if ((offset > 0)); then
__atuin_clear_prompt_cache[offset]=${__atuin_clear_prompt_cache[0]}$(
tput cuu "$offset" 2>/dev/null || tput UP "$offset" 2>/dev/null
tput dl "$offset" 2>/dev/null || tput DL "$offset" 2>/dev/null
tput il "$offset" 2>/dev/null || tput AL "$offset" 2>/dev/null
)
fi
fi
printf '%s' "${__atuin_clear_prompt_cache[offset]}"
}
__atuin_accept_line() {
local __atuin_command=$1
# Reprint the prompt, accounting for multiple lines
local __atuin_prompt __atuin_prompt_offset
__atuin_evaluate_prompt
__atuin_clear_prompt "$__atuin_prompt_offset"
printf '%s\n' "$__atuin_prompt$__atuin_command"
# Add it to the bash history
history -s "$__atuin_command"
# Assuming bash-preexec
# Invoke every function in the preexec array
local __atuin_preexec_function
local __atuin_preexec_function_ret_value
local __atuin_preexec_ret_value=0
for __atuin_preexec_function in "${preexec_functions[@]:-}"; do
if type -t "$__atuin_preexec_function" 1>/dev/null; then
__atuin_set_ret_value "${__bp_last_ret_value:-}"
"$__atuin_preexec_function" "$__atuin_command"
__atuin_preexec_function_ret_value=$?
if [[ $__atuin_preexec_function_ret_value != 0 ]]; then
__atuin_preexec_ret_value=$__atuin_preexec_function_ret_value
fi
fi
done
# If extdebug is turned on and any preexec function returns non-zero
# exit status, we do not run the user command.
if ! { shopt -q extdebug && ((__atuin_preexec_ret_value)); }; then
# Juggle the terminal settings so that the command can be interacted
# with
local __atuin_stty_backup
__atuin_stty_backup=$(stty -g)
stty "$ATUIN_STTY"
# Execute the command. Note: We need to record $? and $_ after the
# user command within the same call of "eval" because $_ is otherwise
# overwritten by the last argument of "eval".
__atuin_set_ret_value "${__bp_last_ret_value-}" "${__bp_last_argument_prev_command-}"
eval -- "$__atuin_command"$'\n__bp_last_ret_value=$? __bp_last_argument_prev_command=$_'
stty "$__atuin_stty_backup"
fi
# Execute preprompt commands
local __atuin_prompt_command
for __atuin_prompt_command in "${PROMPT_COMMAND[@]}"; do
__atuin_set_ret_value "${__bp_last_ret_value-}" "${__bp_last_argument_prev_command-}"
eval -- "$__atuin_prompt_command"
done
# Bash will redraw only the line with the prompt after we finish,
# so to work for a multiline prompt we need to print it ourselves,
# then go to the beginning of the last line.
__atuin_evaluate_prompt
printf '%s' "$__atuin_prompt"
__atuin_clear_prompt 0
}
__atuin_history() {
# Default action of the up key: When this function is called with the first
# argument `--shell-up-key-binding`, we perform Atuin's history search only
# when the up key is supposed to cause the history movement in the original
# binding. We do this only for ble.sh because the up key always invokes
# the history movement in the plain Bash.
if [[ ${BLE_ATTACHED-} && ${1-} == --shell-up-key-binding ]]; then
# When the current cursor position is not in the first line, the up key
# should move the cursor to the previous line. While the selection is
# performed, the up key should not start the history search.
# shellcheck disable=SC2154 # Note: these variables are set by ble.sh
if [[ ${_ble_edit_str::_ble_edit_ind} == *$'\n'* || $_ble_edit_mark_active ]]; then
ble/widget/@nomarked backward-line
local status=$?
READLINE_LINE=$_ble_edit_str
READLINE_POINT=$_ble_edit_ind
READLINE_MARK=$_ble_edit_mark
return "$status"
fi
fi
# READLINE_LINE and READLINE_POINT are only supported by bash >= 4.0 or
# ble.sh. When it is not supported, we localize them to suppress strange
# behaviors.
[[ ${BLE_ATTACHED-} ]] || ((BASH_VERSINFO[0] >= 4)) ||
local READLINE_LINE="" READLINE_POINT=0
local __atuin_output
__atuin_output=$(ATUIN_SHELL_BASH=t ATUIN_LOG=error ATUIN_QUERY="$READLINE_LINE" atuin search "$@" -i 3>&1 1>&2 2>&3)
# We do nothing when the search is canceled.
[[ $__atuin_output ]] || return 0
if [[ $__atuin_output == __atuin_accept__:* ]]; then
__atuin_output=${__atuin_output#__atuin_accept__:}
if [[ ${BLE_ATTACHED-} ]]; then
ble-edit/content/reset-and-check-dirty "$__atuin_output"
ble/widget/accept-line
else
__atuin_accept_line "$__atuin_output"
fi
READLINE_LINE=""
READLINE_POINT=${#READLINE_LINE}
else
READLINE_LINE=$__atuin_output
READLINE_POINT=${#READLINE_LINE}
fi
}
# shellcheck disable=SC2154
if [[ ${BLE_VERSION-} ]] && ((_ble_version >= 400)); then
ble-import contrib/integration/bash-preexec
# Define and register an autosuggestion source for ble.sh's auto-complete.
# If you'd like to overwrite this, define the same name of shell function
# after the $(atuin init bash) line in your .bashrc. If you do not need
# the auto-complete source by atuin, please ad
|