Colorindo seu terminal e o ambiente Shell?

Eu também uso:

export TERM=xterm-color
export GREP_OPTIONS='--color=auto' GREP_COLOR='1;32'
export CLICOLOR=1
export LSCOLORS=ExFxCxDxBxegedabagacad

E se você gosta de colorir seu Prompt, os vars de cores definidos podem ser úteis:

export COLOR_NC='\e[0m' # No Color
export COLOR_WHITE='\e[1;37m'
export COLOR_BLACK='\e[0;30m'
export COLOR_BLUE='\e[0;34m'
export COLOR_LIGHT_BLUE='\e[1;34m'
export COLOR_GREEN='\e[0;32m'
export COLOR_LIGHT_GREEN='\e[1;32m'
export COLOR_CYAN='\e[0;36m'
export COLOR_LIGHT_CYAN='\e[1;36m'
export COLOR_RED='\e[0;31m'
export COLOR_LIGHT_RED='\e[1;31m'
export COLOR_PURPLE='\e[0;35m'
export COLOR_LIGHT_PURPLE='\e[1;35m'
export COLOR_BROWN='\e[0;33m'
export COLOR_YELLOW='\e[1;33m'
export COLOR_GRAY='\e[0;30m'
export COLOR_LIGHT_GRAY='\e[0;37m'

E então meu prompt é algo como isto:

case $TERM in
     xterm*|rxvt*)
         local TITLEBAR='\[\033]0;\u ${NEW_PWD}\007\]'
          ;;
     *)
         local TITLEBAR=""
          ;;
    esac

local UC=$COLOR_WHITE               # user's color
[ $UID -eq "0" ] && UC=$COLOR_RED   # root's color

PS1="$TITLEBAR\n\[${UC}\]\u \[${COLOR_LIGHT_BLUE}\]\${PWD} \[${COLOR_BLACK}\]\$(vcprompt) \n\[${COLOR_LIGHT_GREEN}\]→\[${COLOR_NC}\] "  

$ (vcprompt) está chamando um script python no meu ~/sbin que imprime informações de controle de versão sobre o caminho atual. Inclui suporte para Mercurial, Git, Svn, Cvs, etc. O autor de o script tem o fonte aqui .

Esta é a fonte completa da minha configuração de Prompt:

grep e ls já foram mencionados, se você quiser muito mais cores, confira Generic Colorizer , seu objetivo inicial era colorir arquivos de log, mas logo após Na caixa, ele também coloriza ping, traceroute, gcc, make, netstat, diff, last, ldap e cvs.

É facilmente estendido se você conhece expressões regulares. Adicionei ps e nmap à lista (se você entrar em grc ficarei feliz em compartilhar os arquivos .conf para essas duas ferramentas)

(Instalando-o via synaptic, pacman, e da mesma forma, você pode ter melhor sorte procurando por "grc")

Eu aprimorei meu .bashrc ao longo dos anos para trabalhar no OSX e no Ubuntu.
Também reduzi o tamanho para 28 linhas com instruções de condição compactas.
Com isso, meu prompt do PS1 se parece com: 

com tempo em vermelho, nome de usuário em verde, nome da máquina em azul claro, pwd em azul mais escuro e ramo git em amarelo.

Recurso do meu prompt do PS1:

• mostra ramo git!
• caminhos de diretório longos (mais de 6 elementos) são 'aparados' para mostrar os 3 e 3 melhores diretórios com _ entre então (esse é o pwd sed parte de LOCATION).
• retorno de carro no final, para que o prompt esteja sempre à esquerda!

As linhas relevantes do meu .bashrc arquivo são:

git_branch () { git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/\1/'; }
Host='\033[02;36m\]\h'; Host=' '$Host
TIME='\033[01;31m\]\t \033[01;32m\]'
LOCATION=' \033[01;34m\]`pwd | sed "s#\(/[^/]\{1,\}/[^/]\{1,\}/[^/]\{1,\}/\).*\(/[^/]\{1,\}/[^/]\{1,\}\)/\{0,1\}#\1_\2#g"`'
BRANCH=' \033[00;33m\]$(git_branch)\[\033[00m\]\n\$ '
PS1=$TIME$USER$Host$LOCATION$BRANCH
PS2='\[\033[01;36m\]>'

Para sl com cores quando disponíveis e sem erros quando não (por exemplo, OSX):

ls --color=al > /dev/null 2>&1 && alias ls='ls -F --color=al' || alias ls='ls -G'

Cores para páginas do manual ( mais detalhes ):

function _colorman() {
  env \
    LESS_TERMCAP_mb=$(printf "\e[1;35m") \
    LESS_TERMCAP_md=$(printf "\e[1;34m") \
    LESS_TERMCAP_me=$(printf "\e[0m") \
    LESS_TERMCAP_se=$(printf "\e[0m") \
    LESS_TERMCAP_so=$(printf "\e[7;40m") \
    LESS_TERMCAP_ue=$(printf "\e[0m") \
    LESS_TERMCAP_us=$(printf "\e[1;33m") \
      "[email protected]"
}
function man() { _colorman man "[email protected]"; }
function perldoc() { command perldoc -n less "[email protected]" |man -l -; }

Cores para grep (1;32 é verde brilhante, veja outras postagens aqui para outras cores):

GREP_OPTS='--color=auto'      # for aliases since $GREP_OPTIONS is deprecated
GREP_COLOR='1;32'             # (legacy) bright green rather than default red
GREP_COLORS="ms=$GREP_COLOR"  # (new) Matching text in Selected line = green
alias   grep='grep $GREP_OPTS'
alias egrep='egrep $GREP_OPTS'
alias fgrep='fgrep $GREP_OPTS'

Mais cores para GNU ls :

# use the config at ~/.dircolors if it exists, otherwise generate anew
eval "$( dircolors --sh $(ls -d ~/.dircolors 2>/dev/null) )"

# Usage: _ls_colors_add BASE NEW [NEW...]
# Have LS color given NEW extensions the way BASE extension is colored
_ls_colors_add() {
  local BASE_COLOR="${LS_COLORS##*:?.$1=}" NEW
  if [ "$LS_COLORS" != "$BASE_COLOR" ]; then
    BASE_COLOR="${BASE_COLOR%%:*}"
    shift
    for NEW in "[email protected]"; do
      if [ "$LS_COLORS" = "${LS_COLORS#*.$NEW=}" ]; then
        LS_COLORS="${LS_COLORS%%:}:*.$NEW=$BASE_COLOR:"
      fi
    done
  fi
  export LS_COLORS
}

_ls_colors_add Zip jar xpi            # archives
_ls_colors_add jpg ico JPG PNG webp   # images
_ls_colors_add ogg opus               # audio (opus now included by default)

CLICOLOR=1   # BSD auto-color trigger (like  ls -G  but for everything)
if ls -ld --color=auto / >/dev/null 2>&1
  then alias ls="ls -ph --color=auto"
  else alias ls="ls -ph"
fi

Instale grc ( Colouriser genérico ) e adicione-o aos seus aliases:

# using this as a variable allows easier calling down lower
export GRC='grc -es --colour=auto'

# loop through known commands plus all those with named conf files
for cmd in g++ head ld ping6 tail traceroute6 `locate grc/conf.`; do
  cmd="${cmd##*grc/conf.}"  # we want just the command
  # if the command exists, alias it to pass through grc
  type "$cmd" >/dev/null 2>&1 && alias "$cmd"="$GRC $cmd"
done

# This needs run-time detection. We even fake the 'command not found' error.
configure() {
  if [[ -x ./configure ]]; then
    colourify ./configure "[email protected]"
  else
    echo "configure: command not found" >&2
    return 127
  fi
}

# GRC plus LS awesomeness (assumes you have an alias for ls)
unalias ll 2>/dev/null
if ls -ld --color=always / >/dev/null 2>&1; then GNU_LS="--color=always"; fi

ll() {
  if [[ -t 1 ]] || [[ -n "$CLICOLOR_FORCE" ]]
    then colourify ls -l $GNU_LS "[email protected]"
    else ls -l "[email protected]"
  fi
}

Cores para diff : Muito conteúdo para uma função, use um script e o alias no seu arquivo rc (desnecessário se você instalou grc ):

#!/usr/bin/Perl
use strict;
use warnings;

open (DIFF, "-|", "diff", @ARGV) or die $!;

my $ydiff = 1;
while (<DIFF>) {
  if (not -t 1) {
    print;
    next;
  }
  chomp;
  $ydiff = 0 if /^[ <>\@+-]/ or ($. == 1 && /^\d+[a-z]{1,5}\d+$/);
  my $color = "";
  if (! $ydiff && /^[\@+-<>]/) {
    $color = (/^[<-](?!--$)/ ? 1 : /^[+>]/ ? 2 : 5);
  } elsif ($ydiff && /\t {6}([<|>])(?:\t|$)/) {
    $color = ($1 eq "<" ? 1 : $1 eq ">" ? 2 : 4);
  }
  $color ? printf ("\e[1;3%dm%s\e[0;0m\n",$color,$_) : print "$_\n";
}
close DIFF;

Cores para o prompt do bash :

# Shorten home dir, cygwin drives, paths that are too long
if [ -d /cygdrive ] && uname -a |grep -qi cygwin; then CYGWIN_OS=1; fi
function PSWD() {
  local p="$*" space A B cols="${COLUMNS:-`tput cols 2>/dev/null || echo 80`}"
  p="${p/$HOME/\~}"         # shrink home down to a tilde
  if [ -n "$CYGWIN_OS" ] && [ "${p#/cygdrive/?/}" != "$p" ]; then
    p="${p:10:1}:${p:11}"   # /cygdrive/c/hi -> c:/hi
  fi
  space="$((${#USER}+${#HOSTNAME}+6))"  # width w/out the path
  if [ "$cols" -lt 60 ]; then echo -n "$N "; space=-29; p="$p$N\b"; fi
  if [ "$cols" -lt "$((space+${#p}+20))" ]; then # < 20 chars for the command
    A=$(( (cols-20-space)/4 ))      # a quarter of the space (-20 for cmd)
    if [ $A -lt 4 ]; then A=4; fi   # 4+ chars from beginning
    B=$(( cols-20-space-A*2 ))      # half (plus rounding) of the space
    if [ $B -lt 8 ]; then B=8; fi   # 8+ chars from end
    p="${p:0:$A}..${p: -$B}"
  fi
  echo "$p"
}

PSC() { echo -ne "\[\033[${1:-0;38}m\]"; }
PR="0;32"       # default color used in Prompt is green
if [ "$(id -u)" = 0 ]; then
    Sudo=41     # root is red background
  Elif [ "$USER" != "${Sudo_USER:-$USER}" ]; then
    Sudo=31     # not root, not self: red text
  else Sudo="$PR"   # standard user color
fi
Prompt_COMMAND='[ $? = 0 ] && PS1=${PS1[1]} || PS1=${PS1[2]}'
PSbase="$(PSC $Sudo)\u$(PSC $PR)@\h $(PSC 33)\$(PSWD \w)"
PS1[1]="$PSbase$(PSC $PR)\$ $(PSC)"
PS1[2]="$PSbase$(PSC  31)\$ $(PSC)"
PS1="${PS1[1]}"
unset Sudo PR PSbase

Defina um prompt em negrito/colorido. De cyberciti.biz e o BashFAQ

# 'tput bold' will work regardless of the foreground and background colors.
# Place the tput output into variables, so they are only execd once.
bold=$(tput bold) # This could also be a color.
reset=$(tput sgr0)
export PS1="\[email protected]\[$bold\]\h\[$reset\]:\w \$ "

Também consegui encontrar configurações de cores que são amplamente suportadas e que não imprimem caracteres desagradáveis ​​em ambientes mais antigos (até mesmo no FreeBSD4!), E parecem funcionar bem se TERM = vt100, xterm, xterm-color. (Em geral). Do meu .bashrc:

# Set some options, based on the OS
OS=`uname -s` 

case "$OS" in
    "SunOS" ) 
        # Solaris ls doesn't allow color, so use special characters
        LS_OPTS='-F'
        alias  ls='ls ${LS_OPTS}'
        ;;
    "Linux" )
        # GNU ls supports colors!
        # See dircolors to customize colors
        export LS_OPTS='--color=auto' 
        alias  ls='ls ${LS_OPTS}'

        # Get color support for 'less'
        export LESS="--RAW-CONTROL-CHARS"

        # Use colors for less, man, etc.
        [[ -f ~/.LESS_TERMCAP ]] && . ~/.LESS_TERMCAP

        export GREP_OPTIONS="--color=auto"

        ;;
    "Darwin"|"FreeBSD")

        # Most FreeBSD & Apple Darwin supports colors
        export CLICOLOR=true
        # Get color support for 'less'
        export LESS="--RAW-CONTROL-CHARS"

        # Use colors for less, man, etc.
        [[ -f ~/.LESS_TERMCAP ]] && . ~/.LESS_TERMCAP

        export GREP_OPTIONS="--color=auto"
        ;;
    * ) 
        echo "Unknown OS [$OS]"
        ;;
esac

Existe uma boa ferramenta para configurar suas cores para o comando ls - http://geoff.greer.fm/lscolors/

Coisas que ainda não foram ditas aqui:

Para colorir a saída de suas compilações com o gcc, há o colorgcc de Johannes Schlüter

Para colorir logs, há multitail

Para colorir qualquer stdout, montei xcol

Eu pessoalmente os uso da ferramenta xcol.

#normal=$(tput sgr0)                      # normal text
normal=$'\e[0m'                           # (works better sometimes)
bold=$(tput bold)                         # make colors bold/bright
red="$bold$(tput setaf 1)"                # bright red text
green=$(tput setaf 2)                     # dim green text
fawn=$(tput setaf 3); beige="$fawn"       # dark yellow text
yellow="$bold$fawn"                       # bright yellow text
darkblue=$(tput setaf 4)                  # dim blue text
blue="$bold$darkblue"                     # bright blue text
purple=$(tput setaf 5); Magenta="$purple" # Magenta text
pink="$bold$purple"                       # bright Magenta text
darkcyan=$(tput setaf 6)                  # dim cyan text
cyan="$bold$darkcyan"                     # bright cyan text
gray=$(tput setaf 7)                      # dim white text
darkgray="$bold"$(tput setaf 0)           # bold black = dark gray text
white="$bold$gray"                        # bright white text

Eu uso essas variáveis ​​nos meus scripts assim

echo "${red}hello ${yellow}this is ${green}coloured${normal}"

Também gosto desta pequena função coloredEcho (encontrada no Stack Overflow)

function coloredEcho(){
    local exp=$1;
    local color=$2;
    if ! [[ $color =~ '^[0-9]$' ]] ; then
       case $(echo $color | tr '[:upper:]' '[:lower:]') in
        black) color=0 ;;
        red) color=1 ;;
        green) color=2 ;;
        yellow) color=3 ;;
        blue) color=4 ;;
        Magenta) color=5 ;;
        cyan) color=6 ;;
        white|*) color=7 ;; # white or invalid color
       esac
    fi
    tput setaf $color;
    echo $exp;
    tput sgr0;
}

coloredEcho "This text is green" green

Desculpe, não é permitido postar mais links

Eu sugiro que você verifique ZSH e seu plugin oh-my-zsh que possui um dos recursos mais poderosos do console que eu vi . Um deles é escolher o tema para o seu terminal. Este é um exemplo do meu tema ... Em tty, as cores não são tão quentes, mas são as mesmas da foto ... De qualquer maneira, você vai adorar!

Para visualizar a saída diferencial em cores, use colordiff .

Sudo apt-get install colordiff

Canalize qualquer saída no formato diff para o colordiff:

Isso inclui alguns dos formatos alternativos do diff, como -y (lado a lado.)

Como alternativa, se invocado de forma independente (sem nada canalizado), ele atua como um invólucro em torno de 'diff' e colore a saída. Portanto, eu tenho isso no meu .bashrc, também conhecido como 'diff' para colordiff.

# if colordiff is installed, use it
if type colordiff &>/dev/null ; then
    alias diff=colordiff

Para definir o prompt, tenho isso no meu arquivo .bashrc.

#Set variables for foreground colors
fgRed=$(tput setaf 1)     ; fgGreen=$(tput setaf 2)  ; fgBlue=$(tput setaf 4)
fgMagenta=$(tput setaf 5) ; fgYellow=$(tput setaf 3) ; fgCyan=$(tput setaf 6)
fgWhite=$(tput setaf 7)   ; fgBlack=$(tput setaf 0)
#Set variables for background colors
bgRed=$(tput setab 1)     ; bgGreen=$(tput setab 2)  ; bgBlue=$(tput setab 4)
bgMagenta=$(tput setab 5) ; bgYellow=$(tput setab 3) ; bgCyan=$(tput setab 6)
bgWhite=$(tput setab 7)   ; bgBlack=$(tput setab 0)
#Set variables for font weight and text decoration
B=$(tput bold) ; U=$(tput smul) ; C=$(tput sgr0)
#NOTE: ${C} clears the current formatting

if [[ $USER = "root" ]]; then
  PS1="${B}${fgRed}\u${C}@\h(\s): ${fgGreen}\w${C} > "
else
  PS1="${B}${fgCyan}\u${C}@\h(\s): ${fgGreen}\w${C} > "
fi

Isso me dá um prompt que se parece com isso:

[email protected](bash): ~/bin >

O diretório de trabalho está em verde. E o nome do usuário está em negrito e ciano, a menos que eu execute o Shell com Sudo; nesse caso, o nome do usuário ("root") exibe negrito e vermelho.

Pessoalmente, gosto muito de ter os caracteres de controle de formatação armazenados em variáveis, pois facilita a leitura do código para definir o prompt. Também facilita a edição do prompt .

A razão pela qual eu uso tput é que ele deve ser mais suportado universalmente do que o estranho 033[01;31m\] seqüências. Além disso, como um bônus adicional, se você fizer echo $PS1 no prompt, você verá o prompt bruto com cores em vez daquelas seqüências de controle ininteligíveis.

Alguma decoração de texto (negrito) para diferenciar facilmente entre Shell raiz e não raiz. Para Zsh:

if test $UID = 0
    then PS1="%B${PS1}%b "
fi

Para Bash:

if test $UID = 0
    then PS1="\033[1m${PS1}\033[0m"
fi

Eu apenas me perguntei a mesma coisa. Eu tenho minha própria abordagem, mas estou procurando alternativas.

Eu escrevo wrappers bash em torno de chamadas de programa e canalizo sua saída por sed. O que eu gosto sobre sed é que ele modifica e ecoa cada linha imediatamente => sem muito buffer. No entanto, não gosto que, para cada chamada para um programa agrupado, o código sed seja analisado e compilado.

Por exemplo, é isso que faço para colorir a saída de ip:

#
# Colorcodes
#
NORMAL=`echo -e '\033[0m'`
RED=`echo -e '\033[31m'`
GREEN=`echo -e '\033[0;32m'`
LGREEN=`echo -e '\033[1;32m'`
BLUE=`echo -e '\033[0;34m'`
LBLUE=`echo -e '\033[1;34m'`
YELLOW=`echo -e '\033[0;33m'`


#
# command: ip
# highlight ip addresses, default route and interface names
#

IP4=$GREEN
IP6=$LBLUE
IFACE=${YELLOW}
DEFAULT_ROUTE=$LBLUE

IP_CMD=$(which ip)

function colored_ip()
{
${IP_CMD} [email protected] | sed \
    -e "s/inet [^ ]\+ /${IP4}&${NORMAL}/g"\
    -e "s/inet6 [^ ]\+ /${IP6}&${NORMAL}/g"\
    -e "s/^default via .*$/${DEFAULT_ROUTE}&${NORMAL}/"\
    -e "s/^\([0-9]\+: \+\)\([^ \t]\+\)/\1${IFACE}\2${NORMAL}/"
}

alias ip='colored_ip'

Você pode usar meu cf para colorir nomes de arquivos na linha de comando, é um colorizador rápido e rápido baseado em awk que funciona através de pipes - colorindo nomes de arquivos no Truecolor sRGB.

Ele tem uma configuração padrão de cores vivas e, ao contrário de ls, não sofre uma penalidade de desempenho por adicionar novas cores. (É necessário varrer toda a cadeia LS_COLORS para cada erro).

https://github.com/AdamDanischewski/cf

Acho Solarized útil. É um projeto elegante, com cores uniformes para muitas aplicações.

http://ethanschoonover.com/solarizedhttps://github.com/altercation/solarized

Uma ótima ferramenta de uso geral - Python para colorir a saída dos comandos é ' colout '

Você atribui a ele uma regex com N grupos, seguida por uma lista separada por vírgulas de N cores. Qualquer texto que corresponda a um grupo será exibido na cor correspondente.

Por exemplo, se você estiver olhando para alguma saída de teste:

python -m unittest discover -v

então você pode enfeitar com:

python -m unittest discover -v 2>&1 | colout '(.*ERROR$)|(.*FAIL$)|(\(.*\))' red,yellow,black bold

Veja como minha regex tem três grupos (parênteses) seguidos por três cores (e opcionalmente três estilos), mas usei uma abreviação para definir todas as cores para 'negrito', para o grupo 'preto', que corresponde ao texto entre colchetes , sai como cinza escuro.)

Observe também como eu tive que adicionar 2>&1 até o final da invocação Python, porque a saída do unittest está no stderr, então eu a transferi para stdout para que eu pudesse canalizá-lo para o colout.

Geralmente, é tão fácil de usar que, muitas vezes, eu me pego criando novas invocações de colout on-the-fly e reutilizando ou modificando-as no meu histórico de linha de comando.

A única desvantagem disso é que ele vem como um Python, não como um executável autônomo, portanto, você precisa instalá-lo usando pip ou Sudo python setup.py install.

Você pode tentar um projeto que também ajude a colorir os scripts de saída, chamado ScriptEchoColor no source forge: http://scriptechocolor.sourceforge.net/

ex.:

echoc "@{lr}text output in light red"
echoc "@{bLGu}text outpus in blue, light green background and underlined"
echoc "you @{lr} can @{bLGu} mix @{-a} it all too"
echoc -x "ls" #executes ls command and colorizes it automatically to be easy to be seen

As cores automáticas são configuráveis.

Este é um exemplo feito com ele: 

Eu uso invólucro de cor .

o cw é um invólucro de cor ANSI em tempo real e não intrusivo para comandos comuns baseados em unix no GNU/linux. O cw foi projetado para simular o ambiente dos comandos que estão sendo executados, de modo que se uma pessoa digitar 'du', 'df', 'ping' etc. no Shell, colorirá automaticamente a saída em tempo real, de acordo com uma definição arquivo contendo o formato de cor desejado. O cw suporta cores de correspondência curinga, cores tokenizadas, cabeçalhos/rodapés, cores de cenário de caso, cores de definição dependentes da linha de comando e incluem mais de 50 arquivos de definição predefinidos.

É quase perfeito, mas depois que descobri que o ps no Shell interativo retorna uma saída diferente comparando o ps em um pipe.

se você quiser deixar seu vim colorido como eu, sugiro que você siga duas etapas:

1. aprenda a ativar o recurso seguindo este link: ative a sintaxe da cor realçada no vi ou vim .

etapas principais no link:

1. Edite o arquivo ~/.vimrc digitando o comando: vi ~/.vimrc

2. Anexe a seguinte opção: sintaxe ativada

3. Salve e feche o arquivo

4. Teste-o executando o comando vim: vim foo.sh

2. encontre o esquema de cores desejado e use-o. O esquema que eu uso: o esquema que estou usando

Gostaria de anunciar humildemente minha publicação recente de ta ou textattr , uma biblioteca e comando- ferramenta de linha que visa facilitar a adição de cores e atributos para embelezar a saída do terminal do seu programa, traduzindo especificações legíveis por humanos em códigos de escape ANSI.

Por exemplo:

echo "The Git repo $(ta yellow)${CUR_REPO}$(ta off) is $(ta green)up-to-date$(ta off)"

ou ainda mais curto:

echo "The Git repo $(ta y)${CUR_REPO}$(ta f) is $(ta g)up-to-date$(ta f)"

ou uma alternativa:

tawrite "The Git repo " @y ${CUR_REPO} @f " is " @g up-to-date @f "\n"

lhe dará algo como:

Atualmente, esta biblioteca é utilizável em quatro idiomas C, C++, D e Python além do uso da linha de comando do seu Shell favorito.

Observe que ele não colore automaticamente a saída de outros programas. É um utilitário que ajuda você a não precisar se lembrar dos códigos abstrusos. Você só precisa usar os nomes óbvios das cores ou seus nomes fáceis de lembrar rgb cmyk w(hite) (of) f abreviações.

Para mais detalhes, visite o repositório textattr .

Para Mac, você pode usar o seguinte, conforme especificado aqui

if [ "$TERM" = xterm ]; then TERM=xterm-256color; fi

Se bash é sua escolha, eu recomendo oh-my-bash . Se zsh é sua escolha, eu recomendo oh-my-zsh . Ambos suportam a colorização do seu terminal e saída diferente.