Native support for R `cli` package ANSI-styled output in knitr engine

[coatless]

Summary

R code using the cli package produces unstyled, plain text output in Quarto HTML documents. The ANSI escape sequences are stripped, losing all formatting (colors, bold, emphasis). While Quarto 1.7+ added ANSI support for Jupyter/Julia, R/knitr documents still lack native handling.

Background

The cli package is widely used in the R ecosystem (tidyverse, devtools, usethis, etc.). Many custom print methods leverage cli for informative output. Without native support, Quarto users see degraded output quality compared to RStudio console or terminal rendering.

Minimal Reproducible Example

Save as cli-demo.qmd and render with quarto render cli-demo.qmd:

---
title: "CLI Output Demo"
format: html
---

```{r}
#| echo: false
library(cli)

demo_behavior <- function() {
  cli_h1("Status Report")
  cli_alert_success("All tests passed")
  cli_alert_warning("Memory usage high")
  cli_alert_danger("Connection failed")
}

demo_behavior()
```

Output Comparison

Console Output (Expected)	Quarto Rendered Output (Actual)

Desired Output

Mirror RStudio with a light grey background for CLI output:

Or, just the regular CLI output:

Expected vs Actual Behavior

Aspect	Expected	Actual
Colors	Styled with appropriate colors (green ✔, yellow ⚠, red ✖)	Plain monochrome text
Formatting	Bold headers, styled alerts	No text styling
Icons	Unicode symbols rendered with color context	Symbols appear but lack styling
Background	Terminal-style grey background	White/default background

Current Workaround

Users must manually configure custom knitr hooks using fansi in every document:

```{r}
#| include: false
options(crayon.enabled = TRUE, cli.num_colors = 256)

ansi_aware_handler <- function(x, options) {
  paste0(
    '<pre class="r-output"><code>',
    fansi::sgr_to_html(x = htmltools::htmlEscape(x), warn = FALSE, term.cap = "256"),
    '</code></pre>'
  )
}

knitr::knit_hooks$set(
  output = ansi_aware_handler,
  message = ansi_aware_handler,
  warning = ansi_aware_handler,
  error = ansi_aware_handler
)
```

This is non-obvious, requires additional dependencies (fansi, htmltools), and must be repeated in every document.

Note

The workaround produces separate <pre> blocks for each cli statement, which may result in extra vertical spacing. This is normal knitr behavior (one output block per cat()/message() call). If desired, CSS can be used to collapse consecutive output blocks:

```{=html}
<style>
pre.r-output {
  margin: 0;
  padding: 0;
}
pre.r-output + pre.r-output {
  border-top: none;
}
</style>
```

Proposed Solution

Add native ANSI processing for R/knitr output, similar to the fix in PR #7813. Also consider adding a feature flag or three for the new behavior:

1. Add a chunk option like ansi: true to enable ANSI-to-HTML conversion
2. Document-level YAML option such as execute: ansi-colors: true
3. Terminal-style background for ANSI output blocks (grey background to visually distinguish from regular output)

Related Issues

Issue	Title	Status
#5746	knitr: process ANSI color codes	Open
#3730	Support ANSI colour output with downlit	Open
#4204	ASCII escape codes should be stripped or processed to HTML	Closed (Jupyter only)
Discussion #3957	{cli} output not captured by quarto slides	Active

Environment

• Quarto version: 1.8.26
• R version: 4.5.2
• cli package version: 3.6.5
• OS: macOS 26.2

[cderv]

Thanks for the really good issue description. That helps !

This is an idea that is also since some time now at the knitr / rmarkdown level or cli / crayon level.

Color has been turned of in cli for knitr context: r-lib/cli@e83f3d2

This is why options(crayon.enabled = TRUE, cli.num_colors = 256) is required to re-activate it.

Thinking: Should this mean we should get a broader knitr support and no set if off by default in cli ?

As context there was this past discussion:

• Think about how to colour html output r-lib/crayon#24

We indeed did it for Jupyter but for errors only - I don't think this is generalize to all output.

So we need to think if this is quarto level feature or R package level feature. Inside Quarto, this feature (ansi: true flag) would be format specific I guess (only for HTML), and engine specific (only for knitr engine).

Current solution is indeed adding the hooks where needed (directly or using includes)

```{r color}
#| echo: false
#| output: asis
# crayon needs to be explicitly activated in Rmd
options(crayon.enabled = TRUE)
# Hooks needs to be set to deal with outputs
# thanks to fansi logic
old_hooks <- fansi::set_knit_hooks(knitr::knit_hooks, 
                                   which = c("output", "message", "error"))
```

This is non-obvious, requires additional dependencies (fansi, htmltools), and must be repeated in every document.

I guess this is the main advantage to make it part of rmarkdown/knitr or quarto directly. As this is R specific, I am thinking about knitr directly - but this is may not be a good place after all. I'll think about where.

[coatless]

@cderv From reading, this looks primarily an issue the knitr author wanted to avoid. I'm happy to try to side step that by sending a patch over to cli that enables a similar hook to fansi by relying on a built-in feature cli feature: cli::ansi_html() and cli::ansi_html_style(). I followed this path after finding a gentle hint from @gaborcsardi in Discussion #3957. I should note there's precedents for having this kind of helper inside of cli, c.f. cli::test_that_cli() for interacting with testthat.

Demo document for you:

---
title: "CLI Output Demo"
format: html
---

```{r}
#| label: cli-hooks
#| echo: false
#| output: asis

#' Set knitr hooks for ANSI-aware output using cli
#'
#' @param hooks The knitr::knit_hooks object
#' @param which Character vector of hooks to set
#' @param style Logical, whether to include CSS styles
#' @param palette Color palette passed to cli::ansi_html_style()
#' @return Invisibly returns the old hooks
cli_set_knit_hooks <- function(
    hooks,
    which = c("output", "message", "warning", "error"),
    style = TRUE,
    palette = "vscode"
) {
  old_hooks <- hooks$get(which)

  ansi_aware_handler <- function(x, options) {
    # Skip empty or whitespace-only output
    if (!nzchar(trimws(x))) {
     return(NULL)
    }
    # Convert ANSI to HTML and wrap in <pre><code>
    paste0(
      '<pre class="r-output"><code>',
      cli::ansi_html(x, escape_reserved = TRUE),
      '</code></pre>'
    )
  }

  hook_list <- setNames(replicate(length(which), ansi_aware_handler, simplify = FALSE), which)
  do.call(hooks$set, hook_list)

  if (style && knitr::is_html_output()) {
    # Inject CSS for ANSI styles
    ansi_css <- format(cli::ansi_html_style(palette = palette))
    # Custom CSS to adjust spacing between outputs
    custom_css <- "
pre.r-output {
  margin: 0;
  padding: 0;
}
pre.r-output + pre.r-output {
  border-top: none;
}"
    cat("<style>", ansi_css, custom_css, "</style>", sep = "\n")
  }

  invisible(old_hooks)
}


options(crayon.enabled = TRUE, cli.num_colors = 256)
old_hooks <- cli_set_knit_hooks(knitr::knit_hooks,
                                 which = c("output", "message", "error"))
```

```{r}
#| echo: false
library(cli)

demo_behavior <- function() {
  cli_h1("Status Report")
  cli_alert_success("All tests passed")
  cli_alert_warning("Memory usage high")
  cli_alert_danger("Connection failed")
}

demo_behavior()
```

[cderv]

Really interesting ! I was not aware of cli::ansi_html() and cli::ansi_html_style().

this looks primarily an issue the knitr author wanted to avoid

I could rediscuss this topic in one of our next meeting.
Adding a cell option for knitr engine in quarto alone would only make this a feature for quarto users, while it seems to be more broader as it could benefit R Markdown users if we do it at knitr level, adding a suggest to cli

But anyhow, we could start in Quarto.

I'm happy to try to side step that by sending a patch over to cli

This would be a nice first step. This feature would be mainly backed by R code, and we need to find a place for it. R code in Quarto is not in a package somewhere which is not ideal. There is the quarto package, but this would not be core feature. If cli can offer a helper based on its internal to support formatting in knitr context, that seems a good place. Then, quarto CLI or knitr R package could check format and activate the hook setup.