These programs replace the standard UNIX commands for working with files: touch, mkdir, mv, cp, rm. The new utils are designed for interactive use and to prevent frustration and loss of data.

The new utils are new to create files and directories, move, copy and delete.

See Three letters are too long for shorter names and replacing the standard UNIX commands.

Scenario:

📂 root // <- current working directory
├ 📂 dogs
├ 📂 cats
├ 📂 plants
│ └ 📜 daisy // text: 🌼
├ 📜 rugby // text: 🏉
└ 📜 tennis // text: 🎾

Irreversible actions include:

• deleting a file or a directory
• overwriting a file with different contents
• overwriting a directory with different files contents

The UNIX mv a b command performs a very different operation based on whether b does not exist or is a directory or a file (a move or a rename with a possible overwrite). In human-utils you instead choose which operation to perform (either via the path separator suffix or via explicit options).

The only change in behavior based on the state of the file tree in human-utils is whether you will be asked to proceed or not.

If a directory is needed to perform any command, but it doesn't exist, it will be created. This applies to multiple nested directories as well. The behavior is similar to running the UNIX command mkdir -p with the appropriate argument before every operation.

The move and copy commands' behaviors should be closely related: a mv should behave like a cp followed by rm of the original file(s), yet the UNIX interface for these commands differs (for example, cp changes behavior based on a trailing path separator on source, but mv doesn't). human-utils instead maintain a consistent interface between the two commands.

Creates one or more files or directories.

You can make aliases to these utils and even shadow existing UNIX commands. To avoid unexpected behavior in existing scripts, create the aliases only in interactive sessions.

For example in Fish shell config.fish:

if status is-interactive
    # alias ne new
    alias mv mov
    alias cp cop
    alias rm del # or `alias de del`
    # alias mkdir "new -d"
    # alias touch "new -f"
end

It's convenient to both create a directory and navigate to it. You can set this up in your shell. The examples below use the command alias c.

Fish:

function c -d "quickly cd and create directory if needed" -w cd
    set cd_output (cd $argv 2>&1)
    if test $status -neq 0
        if test (count $argv) -eq 1 && not test -e $argv[1]
            new -d $argv[1]
            cd $argv[1]
        else
            echo $cd_output
        end
    end
end

These commands can change the state of your file system. They are built to be used from an interactive shell. Interactive shells have the concept of the "current working directory" - the directory from which you're executing a command. Yet in most shells, commands cannot change the working directory. For this reason, there are two command invocations that require a shell integration:

1. mov . /some/where/else - In this case we would obviously want the current working directory to follow the move.
2. del . - In this case we would like the working directory to move up the file tree.

Both scenarios must work when the first argument points to any ancestor of the current working directory.

This can be achieved with the --track-cwd-change <file_path> option, like this:

function mv -w mov
    set tracking_file /tmp/__mov_cwd_change__
    mov --track-cwd-change $tracking_file $argv
    if test -f $tracking_file
        set new_cwd (cat $tracking_file)
        /bin/rm $tracking_file
        cd $new_cwd
    end
end

function rm -w del
    set tracking_file /tmp/__del_cwd_change__
    del --track-cwd-change $tracking_file $argv
    if test -f $tracking_file
        set new_cwd (cat $tracking_file)
        /bin/rm $tracking_file
        cd $new_cwd
    end
end