ANSI escape codes in Scala — \u001B, fansi, scala.io.AnsiColor

// Scala 3 dropped octal escapes (\033) from string literals;
// \u001B (Unicode) is the only spelling that compiles on both
// Scala 2 and Scala 3. \e and \x1b are NOT supported in Scala
// string literals — the same constraint as Java and Kotlin.

object Main extends App {
  println("\u001B[1;31merror:\u001B[0m permission denied")
  println("\u001B[33mwarn:\u001B[0m deprecated flag")
  println("\u001B[32mok:\u001B[0m 142 tests passed")

  // Truecolor — 38;2;R;G;B
  println("\u001B[38;2;255;128;0morange truecolor\u001B[0m")

  // scala.io.AnsiColor — stdlib constants, no extra dep.
  // Console mixes in AnsiColor, so the constants are directly
  // accessible as Console.RED / GREEN / YELLOW / BLUE /
  // MAGENTA / CYAN / WHITE plus _B variants for backgrounds,
  // plus BOLD / UNDERLINED / BLINK / REVERSED / RESET.
  println(Console.RED + "error: " + Console.RESET + "permission denied")
  println(Console.BOLD + Console.GREEN + "ok" + Console.RESET +
          " 142 tests passed")
  println(Console.YELLOW_B + Console.BLACK + " CAUTION " +
          Console.RESET + " brakes wet")
}

// build.sbt:
//   libraryDependencies += "com.lihaoyi" %% "fansi" % "0.5.0"
//
// scala-cli:
//   //> using lib "com.lihaoyi::fansi:0.5.0"

import fansi.{Str, Color, Back, Bold, Underlined, Reversed}

// A fansi.Str carries structured colour spans, NOT raw bytes.
// .render materialises to the actual ANSI byte string.
val err: Str = Color.Red("error: ") ++ Str("permission denied")
println(err.render)

// Compose attributes via ++  (concatenate) or by stacking
// constructors:
val heading: Str =
  Color.Blue(Bold.On(Underlined.On("Section 1")))
println(heading.render)

// .overlay layers an attribute on a sub-range — bold the
// first 5 chars only:
val highlighted: Str =
  Str("FATAL server crashed").overlay(Bold.On, 0, 5)
println(highlighted.render)

// 256-palette via Color.Full / Back.Full (integer 0-255):
println(Color.Full(208)("256-palette orange").render)

// Truecolor — Color.True(r, g, b):
println(Color.True(255, 128, 0)("truecolor orange").render)

// Canonical Scala log scrubber — fansi.Str.ansiRegex is the
// right answer; rolling your own regex misses 256 / truecolor
// SGR forms and OSC sequences:
val dirty = "\u001B[1;31mERROR\u001B[0m at line 42"
val clean = fansi.Str.ansiRegex.replaceAllIn(dirty, "")
println(clean)   // → "ERROR at line 42"

// JVM-portable capability check:
//   - System.console() returns a Console when stdin AND stdout
//     are connected to a real terminal.
//   - Returns null when stdin/stdout is redirected to a file
//     or pipe (so 'scala foo.scala > out.log' disables colour).
//
// Pair with NO_COLOR env-var convention (https://no-color.org).
//
// SBT CAVEAT: SBT wraps the build's stdout to inject its own
// progress UI. Child-process ANSI output from `sbt run`
// sometimes loses colour. Fixes:
//   1) sbt -Dsbt.color=always run
//   2) In build.sbt:
//        ThisBuild / outputStrategy := Some(StdoutOutput)
//   3) Inside the sbt shell:
//        set ThisBuild / outputStrategy := Some(StdoutOutput)
//        reload
//        run
// scala-cli and mill do NOT share this quirk — they pass
// stdout through unchanged.

object AnsiCapable {
  def isCapable: Boolean = {
    if (sys.env.contains("NO_COLOR"))    false
    else if (sys.env.contains("FORCE_COLOR")) true
    else System.console() != null
  }

  def styled(text: String, sgr: String): String =
    if (isCapable) s"\u001B[${sgr}m${text}\u001B[0m" else text
}

@main def demo(): Unit = {
  println(AnsiCapable.styled("OK",   "32"))
  println(AnsiCapable.styled("FAIL", "1;31"))
}

// build.sbt:
//   libraryDependencies ++= Seq(
//     "com.lihaoyi" %% "pprint" % "0.9.0",
//     "org.jline"   %  "jline"  % "3.27.1",
//   )

// --- pprint: coloured pretty-printer (the Ammonite default) ---
import pprint.{pprintln, PPrinter}

case class User(name: String, email: String, age: Int)

// Default printer uses fansi colour for keys, types, strings.
pprintln(User("alice", "[email protected]", 30))
pprintln(List(1, 2, 3, 4, 5).map(x => x * x))

// Switch to the no-colour printer when output isn't a TTY:
val pp: PPrinter =
  if (System.console() != null) PPrinter.Color
  else                          PPrinter.BlackWhite
pp.pprintln(User("bob", "[email protected]", 25))

// --- JLine 3: interactive line editor with history + colour ---
import org.jline.terminal.TerminalBuilder
import org.jline.reader.LineReaderBuilder

val terminal = TerminalBuilder.builder()
  .system(true)
  .build()

val reader = LineReaderBuilder.builder()
  .terminal(terminal)
  .build()

// readLine accepts a prompt that may contain ANSI escapes:
val line = reader.readLine("\u001B[32m> \u001B[0m")
println(s"got: $line")

// JLine handles raw-mode termios on Linux/macOS and ConPTY on
// Windows automatically, so the prompt's ANSI bytes render
// correctly on every platform Scala's own REPL supports.