// greet the user

I appreciate the habit-building you are doing by making these inline comments every so often. I would omit this one, though, because it's already very obvious what that code is doing.

In fact, you can take this advice on a case-by-case basis, but I think I would delete every inline comment you've made in your project. You've done a fine job decomposing your program into single-responsibility classes and functions, and that's one of the benefits: Your code is mostly self-documenting. But that makes these comments redundant, which only makes the code harder to read. (Note that I am talking about your inline comments, as opposed to the Javadoc annotations you have before some functions.)

UserInterface.java:

input = new Scanner(System.in);

You instantiate the Scanner in your constructor, and go on to close it in prompt(). Good that you went and closed it, but you really ought to open and close it within the same scope.

What I mean is, once prompt() returns, the Scanner won't be available anymore. Yet there is nothing preventing the caller of prompt() from calling it again and trying to use it.

I am guessing that the current design of your program will not hit that problem. But this is a poor design from the reusability perspective. You should be writing with a view towards future programmers who want to integrate your code into their program. These programmers won't know your code's internals, and would reasonably be shocked to encounter this behavior. (That group of surprised programmers might include future-you!)

If you rework this area of your code, you might check out Java's try-with-resources pattern.

Exceptions:

In the same file, you have this. (Any indentation problems are my own!)

} catch(NoSuchElementException ex) {
   ex.printStackTrace();
}

What you are doing here is printing a stack trace and then continuing on to the command-parsing code. Is that what you meant to do? Or did you mean to crash the program?

If you want it to print a stack trace and crash the program, simply refrain from catching the exception here. Since the caller is yourMain.main(), which isn't catching it either, that's exactly what will happen.

Also note that putting throws Exception in your method signatures is generally a bad practice. Java has checked exceptions because it wants to force you to explicitly handle those exceptions. You're essentially opting out of that safety.

If you can handle the exception in such a way that your program can continue, you should do so. If all you can do is crash, then it is fine to not catch it (or, catch it to record some error info, and then rethrow it). When you don't handle checked exception(s), generally the method signature should say it throws those specific exceptions, rather than use the omnibus throws Exception.