Fossil Wrapper

    alias  f      {finfo}
    alias  fb     {finfo -b}
    alias  fi     {finfo}
    alias  flog   {finfo}
    alias  heads  leaves;       # for hg refugees
    alias  log    {timeline -t ci}
    alias  not    {extras --dotfiles --ignore {}}
    alias  s      {changes --differ}     ;# instead of redundant `show' interceptor...
    alias  t      {timeline -t ci}
    alias  ticks  {ticket show 1}
    alias  time   {timeline}

    # -- Filters:

    filter status {

    filter colorizeOutput {finfo leaves status} {
        # this used to be `fancy_timeline'. but is now used much less
        # since most of the work is relocated to `reformTimeline'
        # the regex/regsubs below could be tidied up, accordingly...
        #
        # Expressions to match:
        set revnum_rx   {(\]:)(\d+)}
        set artifact_rx {\[([a-f\d]{4})([a-f\d]{2,}\]*)\]}
        set date_rx     {(^|\n|([ ]*\(\d+\) ))((=== )?\d{4}-\d\d-\d\d( ===)?)}
        set time_rx     {\d\d:\d\d:\d\d (UTC)?}
        set current_rx  {\*CURRENT\*}
        set frkmrg_rx   {\*(FORK|MERGE|BRANCH)\*}
        # Colour the output (repeated substitutions on $line):
        set line [regsub $date_rx    $line \\2[coloured blue \\3\\6]]
        set line [regsub $time_rx    $line [coloured yellow &]]

   if {$::config::dbglvl > 98} then {set origlines $lines}

   # join all lines to enable matching patterns across line boundaries:
   set timeline [join $lines ""]

   set rgxdate {(\d{4}-\d\d-\d\d)}
   set rgxtime {(\d\d:\d\d:\d\d)}
   set rgxsha1 {(\[[a-f\d]{6,}\])}

   set rgxtimd {}
   set rgxdatehead {}
   set rgxrev {}
   append rgxtimd {(^|\n)} "\($rgxtime|$rgxdate\)"
   append rgxdatehead {(^|\n)(=== )} $rgxdate {( ===)(\n)}
   set rgxarti {(\[)([a-f\d]{4})([a-f\d]{2,}\])(:)([0-9-]+)}
   append rgxrev $rgxtimd { } $rgxsha1
   set rgxuser {( \()(user:( |(\n\s+)))([^\s]+)}
   set rgxtags {( (tags|branch):)([^)]+)(\))}
   set rgxcurr {\*CURRENT\*}
   set rgxfmbr {\*(FORK|MERGE|BRANCH)\*}

   set p1      {(--- (line|entry) limit \([0-9]+\) reached ---)}

proc reformFinfo-b {lines revnums} {
#--------------------------------------------------
# `finfo -b' needs some special treatment prior to
# further filtering/colorizing
#--------------------------------------------------
   set out {}
   set rgxrev {^([a-f\d]{6,})}
   set cinum  [dict size $revnums]
   set ciwid  [string length $cinum]

   foreach line $lines {
      set words [split $line]

      set rev [lindex $words 0]

proc computeRevnums {params} {
#-----------------------------------------------------------------------
# generate a dictionary of SHA1 keys vs. revision numbers
#-----------------------------------------------------------------------
   set revcnt  0
   set numrev  0
   set rgxtime {^\d\d:\d\d:\d\d}
   set rgxrev  {\[([a-f\d]{6,})([^\]]*)\]}
   set rgxrepo {\-R\s+.+}
   set repo    {}

   regexp $rgxrepo $params repo
   if { [catch {exec fossil timeline -t ci -n 0 -W 0 {*}$repo} timeline] } {
      puts $timeline
      exit 1

   return $revnums
}

proc fixGrep {lines params grepflags} {
   set fname [last $params]
   set finfo [lrange [split [exec fossil finfo -W 0 $fname] \n] 1 end]
   set rgxdate {^\d{4}-\d\d-\d\d}
   set rgxhash {\[([a-f\d]{6,})\]}
   foreach line $finfo {
      regexp "$rgxdate $rgxhash" $line _ cihash
      regexp ", artifact: $rgxhash, branch: .*\\)" $line _ fhash
      # an artifact 'fhash' can be part of multiple checkins. so we
      # have to collect all of them via `dict lappend'
      dict lappend cihashes $fhash \[$cihash\]
   }

   }
   regsub $args $args0 {} opts

   set version [lindex $args 0]
   if { $version != "" } then {
      set hash2num [computeRevnums {}]
      dict for {key val} $hash2num {
         regexp {[a-f\d]{6,}} $key sha1
         dict set num2hash $val $sha1
      }
      if {[dict exists $num2hash $version]} {
         set version [dict get $num2hash $version]
         set args [lreplace $args 0 0 $version]
      }
   }

# Note: tentative interpretation of UUID as chronological revison number
# takes precedence. If you actually mean the SHA1 hash you might need to
# provide a longer initial segment to disambiguate it (e.g. 1234 might not
# suffice if there are already so many checkins).
# ----------------------------------------------------------------------------
   set hash2num [computeRevnums {}]
   dict for {key val} $hash2num {
      regexp {[a-f\d]{6,}} $key sha1
      dict set num2hash $val $sha1
   }
   # we assume canonical use of `amend' as described in its manpage:
   # uuid can be expected to be the first argument.
   set uuid [lindex $params 1]
   if {[dict exists $num2hash $uuid]} {
      set version [dict get $num2hash $uuid]

# Note: tentative interpretation of VERSION as chronological revison number
# takes precedence. If you actually mean the SHA1 hash you might need to
# provide a longer initial segment to disambiguate it (e.g. 1234 might not
# suffice if there are already so many checkins).
# ----------------------------------------------------------------------------
   set hash2num [computeRevnums {}]
   dict for {key val} $hash2num {
      regexp {[a-f\d]{6,}} $key sha1
      dict set num2hash $val $sha1
   }

   set rflagpos  [lsearch $params {-r}]
   set revnumpos [expr $rflagpos + 1]
   set version   [lindex $params $revnumpos]

# Note: tentative interpretation of VERSION as chronological revison number
# takes precedence. If you actually mean the SHA1 hash you might need to
# provide a longer initial segment to disambiguate it (e.g. 1234 might not
# suffice if there are already so many checkins).
# ----------------------------------------------------------------------------
   set hash2num [computeRevnums {}]
   dict for {key val} $hash2num {
      regexp {[a-f\d]{6,}} $key sha1
      dict set num2hash $val $sha1
   }

   set version [last $params]
   if {[dict exists $num2hash $version]} {
      set version [dict get $num2hash $version]
      set params [lreplace $params end end $version]

# suffice if there are already so many checkins).
# ----------------------------------------------------------------------------
   set hash2num [computeRevnums {}]

   # exchange keys and values in the above dictonary. at the same time,
   # strip the square brackets around the hash value:
   dict for {key val} $hash2num {
      regexp {[a-f\d]{6,}} $key sha1
      dict set num2hash $val $sha1
   }

   set tversion {}
   set fversion {}
   set fidx 0
   set tidx 0

   if {![regexp $rgxopt $params revarg]} {return $params}

   set hash2num [computeRevnums {}]

   # exchange keys and values in the above dictonary. at the same time,
   # strip the square brackets around the hash value:
   dict for {key val} $hash2num {
      regexp {[a-f\d]{6,}} $key sha1
      dict set num2hash $val $sha1
   }

   # translate rev. numbers to sha1 hashes and construct the
   # required `diff' arguments:
   regexp $rgxrevnum $revarg numbers
   set revs   [split $numbers :]