Shell – hook-like system for shell

There can't be any predisplay hook as the shell is not involved at all when commands output something to the terminal or any other file.

The hook would have to be in the commands run at the first writing system call made by any process or thread started by the command line to a file descriptor open to the tty device. Or you'd have to redirect the stdout and stderr of the command with some IPC mechanism (would probably have to be a pseudo-tty pair so as to minimise the impact on the command behaviour), and insert the Output: when something is received¹. In any case, that would be quite involved and quite intrusive.

Now, not something I would do, but you could try something like:

preexec() {
  printf '%-*s' $COLUMNS "Output:"
  read -sdR $'pos_before?\e[6n'
}

precmd() {
  read -sdR $'pos_after?\e[6n'
  [[ $pos_after != $pos_before ]] || printf '\r'
}
set +o promptsp

That is, just before running a command output Output: and move the cursor to the right edge of the screen (so the next thing written if any would be at the start of the next line) and record the current cursor position in $pos_before.

And just before the next prompt, query the cursor position again, and if it hasn't moved, move the cursor back to the beginning of the line so the next prompt overrides that Output:. We disable promptsp as it interferes with that.

¹Such a pty-based approach could be implemented with expect for instance:

#! /usr/bin/expect -f

set x 0
set timeout -1
stty raw -echo
log_user 0
spawn -noecho zsh

# tell zsh to send a special sequence before the prompt (precmd)
# and a different one before each command (preexec)
send {precmd() printf "\1\1"; preexec() printf "\2\2";set +o promptsp}
send "\r"

# wait for the second prompt
expect "\1\1"

# set our x flag when the preexec string has been output and reset
# it upon precmd. write "Output:" if some character is received while
# the flag is up.
expect {
  -re "^\2\2" {
    set x 1; exp_continue
  }
  -re "^\1\1" {
    set x 0; exp_continue
  }
  -re "^.\[^\1\2\]*" {
    if {$x} {send_user "Output:\n"; set x 0}
    send_user -- "$expect_out(buffer)"
    exp_continue
  }

  -i $user_spawn_id -re .+ {
   send -- $expect_out(buffer); exp_continue
  }
}

Zsh doesn't have anything like closures or packages or namespaces. Zsh lacks a bunch of things required to have true closures:

• Functions aren't first class. You can't pass functions around as arguments to other functions, and functions can't return other functions. (You can pass the name of a function to call, but that's not the same as passing the function itself).

• You can't have nested functions. All functions in zsh are global. You must prefix your function names to avoid conflicts. Note especially that functions will shadow external programs with the same name. If you have a function called ls, it will be called instead of the program ls. This can be useful, except if you do it by accident.

• Variables are dynamically scoped, not statically scoped like in most modern languages. Even if you could have nested functions, inner functions wouldn't close over the local variables of outer functions in the way you would normally expect. You couldn't use them to make modules the way people do in, say, Javascript.

• Zsh does have anonymous functions, but without any of these other things they're not useful for much.

So basically, the best you can do is to prefix all your functions and global variables.

I'll also point out that you should do define your precmd like this:

% autoload -Uz add-zsh-hook
% add-zsh-hook precmd my_precmd_function

add-zsh-hook lets you hook your function into precmd without it overwriting any other functions that might also want to hook precmd.

What it means to have a function loaded is a separate question. Zsh has an autoloading feature that only loads functions from disk when they're actually called. When you do autoload -Uz foobar, that makes the function named foobar available to call. When you actually call foobar, that loads the definition from disk.