Exercise: Build a CLI Tool with Subcommands

Build the mental model

Most real command-line tools you use every day — git, npm, docker — aren't a single flat command, they're a dispatcher: the first argument names a subcommand, and everything after it belongs to that subcommand. This scaffold builds that exact shape in miniature. case "$subcommand" in ... esac is the idiomatic bash way to do the matching, because unlike a chain of if/elif/fi comparisons, a case block reads as a flat list of "when the value is this, do that" branches — it scales to a dozen subcommands without turning into a wall of brackets, and it supports pattern matching (globs, alternation with |) that a plain string comparison doesn't. The shift right before the case is just as load-bearing as the case itself: without it, "$@" inside cmd_add would still start with the subcommand name, so every handler would have to know its own name and manually skip past it. With shift, each handler function receives exactly the arguments meant for it, as if it were its own independent script — which is also why wrapping each subcommand in its own function (cmd_list, cmd_add, cmd_done) rather than inlining logic into the case branches keeps the dispatcher itself short and lets you test or reuse each handler separately. What this scaffold doesn't yet solve is state: cmd_list works because it reads a hardcoded array that lives in memory only for the lifetime of one script run, but a real task manager needs to remember what you added yesterday, and memory doesn't survive the script process exiting — that's a genuinely different kind of problem from anything earlier lessons dealt with, because every previous exercise ran, printed something, and was done.

Connect it to a real scenario

The scaffold you're handed already proves the dispatcher works: run ./task.sh list and main reads "list" into subcommand, shifts it off, matches it in the case block, and calls cmd_list, which loops over the hardcoded TASKS array and prints each entry with a 1-based index. Run ./task.sh add "Buy bread" and the same dispatch machinery correctly routes you into cmd_add with "Buy bread" as "$1" — but the function body is just a TODO and an echo, so nothing happens to the list. Your job is to make cmd_add and cmd_done do real work while leaving main and the case statement untouched, since they're already correct. For cmd_add, the key realization is that appending "$1" to the in-memory TASKS array would only ever be visible for the rest of this one process — the moment the script exits, that array is gone, so you need to append the new task text as a line in a file on disk (something like a tasks.txt next to the script) so a future invocation can read it back. For cmd_done "$1", think about what safely "removing" a line from a file means in bash: you'll typically read the file, filter out the line matching the given task number, and rewrite the file, or mark that line done in place rather than deleting it mid-read. Once both are wired to the same persisted file, cmd_list also needs to read from that file instead of the hardcoded array, so all three subcommands agree on one source of truth across separate runs of the script.

• case is the idiomatic bash pattern for dispatching on a subcommand name
• shift removes the subcommand from $@ so handler functions only see their own arguments
• A script is a brand-new process every time it runs, so anything a subcommand needs to remember must be written to a file, not just held in a variable

Try the working example

#!/usr/bin/env bash
# task.sh - a tiny CLI with subcommands (add, list, done)
# Usage: ./task.sh <command> [arguments]

# Pretend this is loaded from a real task file; hardcoded here for the demo
TASKS=("Buy milk" "Write report" "Call the plumber")

cmd_list() {
  echo "Tasks:"
  local i=1
  for t in "${TASKS[@]}"; do
    echo "  $i) $t"
    i=$((i + 1))
  done
}

cmd_add() {
  # TODO: append "$1" to TASKS and persist it so future runs see it
  echo "add: not yet implemented"
}

cmd_done() {
  # TODO: mark task number "$1" as complete (e.g. remove it or flag it)
  echo "done: not yet implemented"
}

main() {
  local subcommand="$1"
  shift

  case "$subcommand" in
    list)
      cmd_list
      ;;
    add)
      cmd_add "$@"
      ;;
    done)
      cmd_done "$@"
      ;;
    *)
      echo "Usage: task.sh {add|list|done} [arguments]" >&2
      exit 1
      ;;
  esac
}

main "$@"

$ ./task.sh list
Tasks:
  1) Buy milk
  2) Write report
  3) Call the plumber

$ ./task.sh add "Buy bread"
add: not yet implemented

$ ./task.sh foo
Usage: task.sh {add|list|done} [arguments]

GNU Bash Reference Manual — Conditional Constructs (case) — Bash / Shell Scripting