Building CLI scripts in Clojure

Question

What are the common/standard ways to build CLI scripts in Clojure?

In my view such a method should include the following characteristics:

• A way of easily dealing with arguments, stdin/out/err.

• Without taking too much to boot (ideally having some sort of JIT), otherwise one loses the purpose of hacking things together in one's shell.

• Also it is reasonable to expect a easy way of including one time dependencies without setting up a project (maybe installing them globally).

Ideally, providing a simple example of the solution usage would be much appreciated. Somewhat equivalent to:

#!/bin/bash
    echo "$@"
    cat /dev/stdin

Note: I'm aware that this question was somewhat questioned previously here. But the question is incomplete and the answers don't reach a consensus neither a significant proportion of the solutions that seems to exist.

Answer 1

An option would be Planck which runs on MacOS and Linux. It uses self-hosted ClojureScript, has fast startup and targets JavaScriptCore.

It has a nice SDK and mimics some things from Clojure which you do not have in ClojureScript, e.g. planck.io resembles clojure.java.io. It supports loading dependencies via tools.deps.alpha/deps.edn.

Echoing stdin is as easy as:

(require '[planck.core :refer [*in* slurp]])
(print (slurp *in*))

and printing the command line arguments:

(println *command-line-args*)

...

$ echo "foo" | planck stdin.cljs 1 2 3
foo
(1 2 3)

An example of a standalone script, i.e. not a project, with dependencies: the tree command line tool in Planck.

One caveat is that Planck doesn't support using npm dependencies. So if you need those, go for Lumo which targets NodeJS.

A third option would be joker which is a Clojure interpreter written in Go.

Answer 2

Now that there is new CLI tooling it is possible to create a standalone Clojure script without using third party tools. Once you've got the clj command line tool installed, a script like the one below should just work.

In terms of the original question, this can be as good as any Clojure/JVM CLI program at dealing with command line arguments and system input/output depending on what libraries you :require. I've haven't benchmarked it, so I won't comment on performance but if it worries you then please experiment yourself to see if startup time is acceptable to you. I would say this scores highly on dependency management though, as the script is entirely standalone (apart from the clj tool which is now the recommended way to run Clojure anyway).

File: ~/bin/script.sh

#!/bin/sh

"exec" "clj" "-Sdeps" "{:deps,{hiccup,{:mvn/version,\"1.0.5\"}}}" "$0" "$@"

(ns my-script
  (:require
    [hiccup.core :as hiccup]))

(println
  (hiccup/html
    [:div
      [:span "Command line args: " (clojure.string/join ", " *command-line-args*)]
      [:span "Stdin: " (read-line)]]))

Then ensure it is executable:

$ chmod +x ~/bin/script.sh

And run it:

$ echo "stdin" | script.sh command line args
<div><span>Command line args: command, line, args</span><span>Stdin: stdin</span></div>

NB. This is primarily a shell script which treats the strings on line three as commands to execute. That subsequent execution will run the clj command line tool with the given arguments, which will evaluate those strings as strings (without side effects) and then proceed to evaluate the Clojure code below.

Note also that dependencies are specified as a map passed to clj on line three. You can read more about how that works on the Clojure website. The tokens in the dependency map are separated by commas, which Clojure treats as whitespace but which most shells do not.

Thanks to the good folk on the #tools-deps channel of the "clojurians" Slack group whence this solution came.