Files
luxe/crates/luxe-tui/src/highlight.rs
Evan Whittaker d2129a886f Luxe 0.1.3: your sessions on your phone, joinable sessions, and nested AGENTS.md
- luxe remote puts the sessions on your computer in reach of your own phone or tablet over
  Tailscale: write, steer, answer prompts, send photos, browse files, diffs and GitHub, with a
  paired device and your own Tailscale login.
- luxe join lets another program on the same machine join a running session over the RPC protocol.
- An AGENTS.md in a subfolder reaches the model the first time it works there.
- Long sessions stay fast: no stall before each model call, lighter memory, cheaper drawing.
- A session is open in one Luxe at a time, web_search shares results across its phrasings, and a
  grep glob starting with ! excludes.

The CHANGELOG has the full list.
2026-10-20 02:40:13 -05:00

409 lines
16 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! highlight — syntax highlighting via syntect, in the active theme's colors.
//!
//! syntect parses; it does not choose the colors. The theme it highlights against is a table of
//! [`Role`]s, each a placeholder color, and `paint` swaps every role for the theme's own style
//! when a line is drawn. So a code block, a tool card, a diff and the preview all wear the palette
//! everything else wears, a custom theme or Omarchy's included, and switching themes recolors code
//! at once: the memo holds roles, not colors, so it never goes stale.
//!
//! [`highlight_code`] is memoized: the transcript re-lays out every block on every frame, so an
//! answer with a few fenced blocks, or a handful of `write` cards, would otherwise spend more of
//! each frame here than in the rest of the render path put together.
//!
//! syntect runs on **`fancy-regex`**, not its default Oniguruma binding. Oniguruma is roughly 3.5×
//! faster with identical output, but it is C, and a C toolchain in the dependency graph is a tax on
//! every `cargo install`, every cross-build, and every CI runner. The memo is what makes that trade
//! cheap: the cost is paid once per distinct line, not per frame, and highlighting is per line
//! rather than per file.
use crate::theme::styles::ThemeStyles;
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::str::FromStr;
use std::sync::{Arc, LazyLock, Mutex, MutexGuard, OnceLock};
static SYNTAX_SET: OnceLock<syntect::parsing::SyntaxSet> = OnceLock::new();
static ROLE_THEME: OnceLock<syntect::highlighting::Theme> = OnceLock::new();
fn get_syntax_set() -> &'static syntect::parsing::SyntaxSet {
SYNTAX_SET.get_or_init(syntect::parsing::SyntaxSet::load_defaults_newlines)
}
/// What a stretch of code is, as far as its color goes.
///
/// Few on purpose: a theme has about seven hues, and a role only earns its place by landing on a
/// different one, or by meaning something the markdown renderer already draws its own way.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum Role {
Text,
Punctuation,
Comment,
Keyword,
String,
Escape,
Constant,
Function,
Type,
Tag,
Heading,
Link,
LinkUrl,
Quote,
Code,
Strong,
Emphasis,
ListMarker,
Inserted,
Deleted,
Invalid,
}
impl Role {
const ALL: [Role; 21] = [
Role::Text,
Role::Punctuation,
Role::Comment,
Role::Keyword,
Role::String,
Role::Escape,
Role::Constant,
Role::Function,
Role::Type,
Role::Tag,
Role::Heading,
Role::Link,
Role::LinkUrl,
Role::Quote,
Role::Code,
Role::Strong,
Role::Emphasis,
Role::ListMarker,
Role::Inserted,
Role::Deleted,
Role::Invalid,
];
/// The theme token this role is drawn in, and how.
///
/// The tokens spend the palette on meaning: the accent goes on what you scan a file for, the
/// functions; types take the cool hue so they separate from calls; keywords take
/// `accentSecondary`, the violet most syntax themes give them; punctuation recedes into
/// `muted`. `dim` is never used, since it is a rule color, not a text color. Markdown takes the
/// `md*` tokens, so the preview of a `.md` file wears the colors the rendered answer does.
pub fn token(self) -> (&'static str, Modifier) {
match self {
Role::Text | Role::Strong | Role::Emphasis => (
"text",
match self {
Role::Strong => Modifier::BOLD,
Role::Emphasis => Modifier::ITALIC,
_ => Modifier::empty(),
},
),
Role::Punctuation => ("muted", Modifier::empty()),
Role::Comment => ("muted", Modifier::ITALIC),
Role::Keyword => ("accentSecondary", Modifier::empty()),
Role::String | Role::Inserted => ("success", Modifier::empty()),
Role::Escape | Role::Type => ("info", Modifier::empty()),
Role::Constant => ("warning", Modifier::empty()),
Role::Function | Role::ListMarker => ("accent", Modifier::empty()),
// the palette's berry, which a resolved theme carries only as `thinkingUltra`
Role::Tag => ("thinkingUltra", Modifier::empty()),
Role::Heading => ("mdHeading", Modifier::BOLD),
Role::Link => ("mdLink", Modifier::empty()),
Role::LinkUrl => ("mdLinkUrl", Modifier::empty()),
Role::Quote => ("mdQuote", Modifier::ITALIC),
Role::Code => ("mdCode", Modifier::empty()),
Role::Deleted | Role::Invalid => ("error", Modifier::empty()),
}
}
/// The theme's style for this role: only the foreground and the modifier, so a diff's or a
/// card's background shows through.
pub fn style(self, styles: &ThemeStyles) -> Style {
let (token, modifier) = self.token();
let source = token_style(styles, token).unwrap_or(styles.text);
Style { fg: source.fg, ..Style::default() }.add_modifier(modifier)
}
/// The placeholder color that stands for this role inside syntect.
fn marker(self) -> syntect::highlighting::Color {
syntect::highlighting::Color { r: self as u8, g: 0x1c, b: 0x5e, a: 0xff }
}
fn from_marker(color: syntect::highlighting::Color) -> Role {
Role::ALL.get(usize::from(color.r)).copied().unwrap_or(Role::Text)
}
}
/// The resolved style a theme token names, for the tokens [`Role::token`] uses.
fn token_style(styles: &ThemeStyles, token: &str) -> Option<Style> {
Some(match token {
"text" => styles.text,
"muted" => styles.muted,
"accent" => styles.accent,
"accentSecondary" => styles.accent_secondary,
"info" => styles.info,
"success" => styles.success,
"warning" => styles.warning,
"error" => styles.error,
"thinkingUltra" => styles.thinking_ultra,
"mdHeading" => styles.md_heading,
"mdLink" => styles.md_link,
"mdLinkUrl" => styles.md_link_url,
"mdQuote" => styles.md_quote,
"mdCode" => styles.md_code,
_ => return None,
})
}
/// Scope selectors and the role each takes, in TextMate's vocabulary: the one table both the TUI
/// and the website's code blocks (`examples/shiki_theme.rs`) are colored from.
///
/// The most specific selector that matches wins, in syntect and in TextMate alike, so
/// `keyword.operator` beats `keyword` and an `=` recedes with the punctuation rather than wearing
/// the keyword color. Broad entries come first anyway, since TextMate breaks a tie by taking the
/// later one. `storage.type` is a keyword: the bundled grammars put `fn`, `let`, `def` and `class`
/// under it, and a primitive type in the keyword color is the smaller price.
pub const SCOPES: &[(&str, Role)] = &[
("variable, variable.parameter, variable.other", Role::Text),
("punctuation, meta.brace, keyword.operator, meta.separator", Role::Punctuation),
("comment, punctuation.definition.comment", Role::Comment),
("string, punctuation.definition.string, meta.embedded.string", Role::String),
("constant.character.escape, constant.other.placeholder, string.regexp", Role::Escape),
("constant.numeric, constant.language, constant.other, keyword.other.unit", Role::Constant),
("keyword, storage, storage.type, storage.modifier, keyword.control", Role::Keyword),
(
"entity.name.function, support.function, meta.function-call, variable.function, \
support.macro",
Role::Function,
),
(
"entity.name.type, entity.name.class, entity.name.struct, entity.name.enum, \
entity.name.trait, entity.name.impl, entity.name.namespace, \
entity.other.inherited-class, support.type, support.class",
Role::Type,
),
(
"entity.name.tag, entity.other.attribute-name, meta.annotation, variable.annotation",
Role::Tag,
),
// keys take the cool hue rather than the berry: in a JSON file keys are half the tokens, and a
// warm accent on every one of them reads as alarm
("support.type.property-name, meta.object-literal.key, meta.mapping.key", Role::Type),
("markup.heading", Role::Heading),
("meta.link.inline.description, string.other.link", Role::Link),
("markup.underline.link", Role::LinkUrl),
("markup.quote", Role::Quote),
("markup.raw", Role::Code),
("markup.bold", Role::Strong),
("markup.italic", Role::Emphasis),
(
"markup.list.numbered.bullet, markup.list.unnumbered.bullet, \
punctuation.definition.list_item",
Role::ListMarker,
),
("markup.inserted", Role::Inserted),
("markup.deleted", Role::Deleted),
("invalid, invalid.illegal, message.error", Role::Invalid),
];
/// The syntect theme whose every color is a [`Role`] marker.
fn role_theme() -> &'static syntect::highlighting::Theme {
use syntect::highlighting::{ScopeSelectors, StyleModifier, Theme, ThemeItem, ThemeSettings};
ROLE_THEME.get_or_init(|| Theme {
settings: ThemeSettings {
foreground: Some(Role::Text.marker()),
..ThemeSettings::default()
},
scopes: SCOPES
.iter()
.map(|(selectors, role)| ThemeItem {
scope: ScopeSelectors::from_str(selectors).expect("a well-formed scope selector"),
style: StyleModifier {
foreground: Some(role.marker()),
..StyleModifier::default()
},
})
.collect(),
..Theme::default()
})
}
/// One highlighted line, as roles: what the memo keeps, since it holds for every theme.
pub type RoleLine = Vec<(Role, String)>;
/// Highlights `code` as `lang`, in `styles`' colors.
///
/// Unknown or absent languages fall back to plain text. Memoized; see the module note.
pub fn highlight_code(code: &str, lang: Option<&str>, styles: &ThemeStyles) -> Vec<Line<'static>> {
paint(&highlight_roles(code, lang), styles)
}
/// Highlights `code` as `lang` into roles, for a surface that colors roles itself: the phone app's
/// HTML names each role's theme token as a class. Memoized, like [`highlight_code`].
pub fn highlight_roles(code: &str, lang: Option<&str>) -> Arc<Vec<RoleLine>> {
let key = fingerprint(code, lang);
if let Some(hit) = cache().get(key, code, lang) {
return hit;
}
// Deliberately outside the lock: syntect is the slow part, nothing else needs to wait for it,
// and a panic in it cannot poison the cache it is not holding.
let lines = Arc::new(highlight_uncached(code, lang));
cache().insert(key, code, lang, Arc::clone(&lines));
lines
}
/// Turns roles into the theme's styles.
fn paint(lines: &[RoleLine], styles: &ThemeStyles) -> Vec<Line<'static>> {
lines
.iter()
.map(|line| {
Line::from(
line.iter()
.map(|(role, text)| Span::styled(text.clone(), role.style(styles)))
.collect::<Vec<_>>(),
)
})
.collect()
}
fn highlight_uncached(code: &str, lang: Option<&str>) -> Vec<RoleLine> {
let syntax_set = get_syntax_set();
let syntax = lang
.and_then(|l| syntax_set.find_syntax_by_token(l))
.unwrap_or_else(|| syntax_set.find_syntax_plain_text());
let mut h = syntect::easy::HighlightLines::new(syntax, role_theme());
let mut failed = false;
code.lines()
.map(|line| {
let highlighted = h.highlight_line(line, syntax_set);
if let (Err(error), false) = (&highlighted, failed) {
// once per block: the result is cached, so a repaint never asks again
tracing::debug!(%error, lang, "highlighting failed; showing plain text");
failed = true;
}
line_roles(highlighted, line)
})
.collect()
}
/// A highlighted line as roles, neighbors in one role joined so a line is as few spans as it has
/// colors. A line the highlighter failed on is kept whole as plain text: color is best effort, the
/// source is not, so a failure must not come back as no spans at all.
fn line_roles<E>(
highlighted: Result<Vec<(syntect::highlighting::Style, &str)>, E>,
line: &str,
) -> RoleLine {
let Ok(highlighted) = highlighted else { return vec![(Role::Text, line.to_string())] };
let mut roles: RoleLine = Vec::new();
for (style, text) in highlighted {
let role = Role::from_marker(style.foreground);
match roles.last_mut() {
Some((last, joined)) if *last == role => joined.push_str(text),
_ => roles.push((role, text.to_string())),
}
}
roles
}
// === Memoization ===
/// Entries the cache holds before evicting the least recently used.
///
/// Generous next to what one screen needs, because the working set is every block in the
/// transcript — the render path lays out all of them, not just the visible ones.
const MAX_ENTRIES: usize = 256;
/// Source bytes the cache holds, as a second bound: a few very large blocks should not be able to
/// pin megabytes of highlighted spans just because they are few.
const MAX_BYTES: usize = 2 << 20;
static CACHE: LazyLock<Mutex<Cache>> = LazyLock::new(|| Mutex::new(Cache::default()));
/// A poisoned highlight cache is no reason to take the UI down: every entry is a pure function of
/// its key, so the worst a recovered lock holds is a memo that is still correct.
fn cache() -> MutexGuard<'static, Cache> {
CACHE.lock().unwrap_or_else(|poison| poison.into_inner())
}
/// Highlighted blocks kept between frames.
///
/// Keyed by a hash of the inputs and *verified* against the stored ones on the way out, so a hash
/// collision costs a re-highlight rather than the wrong colors on screen.
#[derive(Default)]
struct Cache {
entries: HashMap<u64, Entry>,
/// Source bytes currently held, kept incrementally so eviction never walks the map twice.
bytes: usize,
/// Logical clock: every lookup and insert stamps its entry, and eviction takes the lowest.
clock: u64,
}
/// One memoized highlight, with the inputs that produced it.
struct Entry {
code: Box<str>,
lang: Option<Box<str>>,
lines: Arc<Vec<RoleLine>>,
used: u64,
}
impl Entry {
/// Whether this entry really is the answer for these inputs (a hash match is not proof).
fn matches(&self, code: &str, lang: Option<&str>) -> bool {
&*self.code == code && self.lang.as_deref() == lang
}
}
impl Cache {
fn get(&mut self, key: u64, code: &str, lang: Option<&str>) -> Option<Arc<Vec<RoleLine>>> {
self.clock += 1;
let clock = self.clock;
let entry = self.entries.get_mut(&key)?;
if !entry.matches(code, lang) {
return None;
}
entry.used = clock;
Some(Arc::clone(&entry.lines))
}
fn insert(&mut self, key: u64, code: &str, lang: Option<&str>, lines: Arc<Vec<RoleLine>>) {
self.clock += 1;
let entry =
Entry { code: code.into(), lang: lang.map(Into::into), lines, used: self.clock };
self.bytes += entry.code.len();
if let Some(replaced) = self.entries.insert(key, entry) {
self.bytes = self.bytes.saturating_sub(replaced.code.len());
}
self.evict();
}
/// Drops least-recently-used entries until both bounds hold.
fn evict(&mut self) {
while self.entries.len() > MAX_ENTRIES || (self.bytes > MAX_BYTES && self.entries.len() > 1)
{
let Some(oldest) =
self.entries.iter().min_by_key(|(_, entry)| entry.used).map(|(key, _)| *key)
else {
return;
};
if let Some(dropped) = self.entries.remove(&oldest) {
self.bytes = self.bytes.saturating_sub(dropped.code.len());
}
}
}
}
/// Hash of everything that changes the highlighted output.
fn fingerprint(code: &str, lang: Option<&str>) -> u64 {
let mut hasher = std::collections::hash_map::DefaultHasher::new();
code.hash(&mut hasher);
lang.hash(&mut hasher);
hasher.finish()
}
#[cfg(test)]
mod tests;