Any ergonomic tools for the command line kernel?

As I said in my comments, it is hard to implement this correctly if you aim for some advanced Dynamic features that work in the command line. However, you can surely use the carriage-return trick on the command line.

The only obstacle here is that Print puts everything on a new line. However, if you write directly to stdout, you don't have this problem. Consider the following small example:

progress[n_, max_] := WriteString["stdout", 
  "\r[" <> StringJoin@Table["#", n] <> 
  StringJoin@Table[" ", max - n] <> "]"
] 

n=0; While[n++<20, Pause[0.2];progress[n,20]]

Edit

Is there any way to make this sensitive to the terminals window size?

Hmm, it's difficult, because you would need feedback from your window how large it is. I don't see a way to do this from the top of my head.

Would be nice to show additional information! Like ETA, Time Taken Already, Percentage

One downside of using \r is that it doesn't delete the line and you have to ensure that your output is either of the same size or longer. Or you use another function to delete the line after an iteration.

Beside this obstacle, running time, ETA, or percentage can be implemented using a closure because you need to remember the starting time and other things.

An implementation for ETA could look like this

Module[{start = Missing, eta, iter = 0},
 ETA[max_Integer] := Module[{},
   If[start === Missing, start = AbsoluteTime[]];
   iter++;
   eta = (AbsoluteTime[] - start)/iter;
   WriteString["stdout", 
    "\r" <> ToString[Round[max*eta - iter*eta]] <> " Seconds left"]
   ]
 ]

and is then used like this

n = 0; While[n++ < 100, ETA[100]; Pause[.1]] 

As you can see, on the first call it initializes the starting time and then, on each iteration, it updates the ETA.

An implementation for a sine-perculator can also be created but it requires that you have many, short iterations so that the display is updated often. However, I don't recommend something like this because it's hard to ensure that the progress display doesn't slow down your overall loop too much.

ProgressBar[] := With[{initTime = AbsoluteTime[]},
  Function[
   Module[{curr = AbsoluteTime[] - initTime, percolate},
    percolate = Round[10*Cos[2*curr] + 10];
    percolate = Append[ConstantArray[" ", percolate], "#"];
    percolate = 
     StringJoin@
      Join[percolate, ConstantArray[" ", 21 - Length[percolate]]];
    Print[
     TemplateApply[
      "[`perc`] `time` Seconds",
      <|
       "perc" -> percolate,
       "time" -> Round[curr, 0.1]
       |>
      ]
     ]
    ]
   ]
  ]

pbar=ProgressBar[]; n=0; While[n++<12^4, pbar[]] 

I have implemented a relatively bare-bones textual frontend for Mathematica called MathLine. It offers Readline-like text input (uses linenoise), which means command history and emacs-style editing. Symbol completion would be easy to implement and is not affected by the same technical challenges of dynamic monitoring mentioned by others. The ergonomic advantage to Mathematica's textual frontend is the Readline features, but I wrote it for very different motivations.

Jim Radford wrote JMath which is similar to MathLine but already has symbol name completion and awareness of window size changes.

It would be nice to have a textual front end with a fuller feature set, including some kind of support for dynamic content. At the very east, non-blocking evaluation is possible without running into the technical issues described by others on this thread. It should be relatively simple to add this feature to existing implementations. I would also like to see syntax highlighting, moving between "cells" for re-evaluation, etc. These more advanced features would probably be better implemented with IPython/PTPython/prompt_toolkit. But alas, nobody has implemented any of this.