path: root/crates/asist-core/src/text.rs

//! Preparación del texto que va a leerse en voz alta.
//!
//! Dos problemas distintos, ambos en el camino crítico de la latencia:
//!
//! 1. **Trocear en frases mientras el modelo escribe.** Esperar a la respuesta
//!    completa antes de sintetizar suma el tiempo del LLM al del TTS. Cortando
//!    por frases, el asistente empieza a hablar mientras sigue pensando.
//! 2. **Quitar lo que no se pronuncia.** El sintetizador lee los asteriscos y
//!    las almohadillas tal cual, así que el markdown que se le escapa al modelo
//!    hay que limpiarlo antes.

/// Trocea un flujo de texto en frases pronunciables.
///
/// La primera frase sale en cuanto es mínimamente decente y las siguientes
/// esperan a tener más cuerpo: el arranque manda en la latencia percibida,
/// pero una vez que suena la voz, las frases largas se entonan mejor.
#[derive(Debug)]
pub struct SentenceSplitter {
    buffer: String,
    emitted: usize,
    /// Longitud mínima de la primera frase.
    first_min: usize,
    /// Longitud mínima de las siguientes.
    rest_min: usize,
    /// Longitud a partir de la cual se corta aunque no haya puntuación, para
    /// que un modelo que no puntúa no deje al asistente mudo.
    hard_max: usize,
}

impl Default for SentenceSplitter {
    fn default() -> Self {
        Self {
            buffer: String::new(),
            emitted: 0,
            first_min: 12,
            rest_min: 40,
            hard_max: 240,
        }
    }
}

impl SentenceSplitter {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_limits(first_min: usize, rest_min: usize, hard_max: usize) -> Self {
        Self {
            first_min,
            rest_min,
            hard_max,
            ..Self::default()
        }
    }

    pub fn emitted(&self) -> usize {
        self.emitted
    }

    /// Añade texto recién llegado y devuelve las frases que ya están completas.
    pub fn push(&mut self, delta: &str) -> Vec<String> {
        self.buffer.push_str(delta);
        let mut out = Vec::new();
        while let Some(sentence) = self.take_ready() {
            out.push(sentence);
        }
        out
    }

    /// Entrega lo que quede al terminar la respuesta.
    pub fn flush(&mut self) -> Option<String> {
        let rest = clean_for_speech(&std::mem::take(&mut self.buffer));
        if !is_speakable(&rest) {
            return None;
        }
        self.emitted += 1;
        Some(rest)
    }

    fn min_len(&self) -> usize {
        if self.emitted == 0 {
            self.first_min
        } else {
            self.rest_min
        }
    }

    fn take_ready(&mut self) -> Option<String> {
        let cut = self.boundary()?;
        let head: String = self.buffer.drain(..cut).collect();
        let head = clean_for_speech(&head);
        if !is_speakable(&head) {
            // Sólo era puntuación o markdown: se descarta sin gastar un turno
            // de síntesis, pero el corte ya se ha consumido.
            return self.take_ready();
        }
        self.emitted += 1;
        Some(head)
    }

    /// Índice de byte por el que cortar, si hay alguno.
    fn boundary(&self) -> Option<usize> {
        let min = self.min_len();
        let mut last_soft = None;

        for (i, c) in self.buffer.char_indices() {
            let end = i + c.len_utf8();
            if end < min {
                continue;
            }
            if is_terminator(c) {
                // El punto de una abreviatura o de un decimal no cierra frase.
                if c == '.' && !ends_sentence(&self.buffer, i) {
                    continue;
                }
                // Sólo cierra si viene un espacio detrás, o si ya no queda
                // nada: si no, se estaría cortando a mitad de «3.14».
                match self.buffer[end..].chars().next() {
                    Some(next) if next.is_whitespace() => return Some(end),
                    None => {}
                    Some(_) => continue,
                }
            }
            // Una coma o un punto y coma valen como corte de emergencia si la
            // frase ya se ha pasado de largo.
            if matches!(c, ',' | ';' | ':') {
                last_soft = Some(end);
            }
            if end >= self.hard_max {
                return Some(last_soft.unwrap_or(end));
            }
        }
        None
    }
}

/// ¿Hay algo que pronunciar?
///
/// Un fragmento que sólo tiene puntuación —lo que queda al limpiar un «**» o
/// unos puntos suspensivos sueltos— cuesta una síntesis entera y no suena a
/// nada, así que no llega a salir del troceador.
pub fn is_speakable(text: &str) -> bool {
    text.chars().any(char::is_alphanumeric)
}

fn is_terminator(c: char) -> bool {
    matches!(c, '.' | '!' | '?' | '…' | '\n')
}

/// ¿El punto en `idx` cierra frase de verdad?
///
/// Descarta decimales («3.14»), elipsis a medio escribir y las abreviaturas
/// más comunes en español, que si no parten la frase justo antes del nombre.
fn ends_sentence(text: &str, idx: usize) -> bool {
    let before = &text[..idx];
    let after = &text[idx + 1..];

    if after.starts_with(|c: char| c.is_ascii_digit())
        && before.ends_with(|c: char| c.is_ascii_digit())
    {
        return false;
    }
    if after.starts_with('.') || before.ends_with('.') {
        return false;
    }
    let word = before
        .rsplit(|c: char| c.is_whitespace())
        .next()
        .unwrap_or("")
        .to_lowercase();
    const ABREVIATURAS: &[&str] = &[
        "sr", "sra", "srta", "dr", "dra", "ud", "uds", "etc", "ej", "p.ej", "av", "núm", "num",
        "pág", "pag", "vol", "art", "ap", "aprox", "ee.uu", "d", "dña",
    ];
    !ABREVIATURAS.contains(&word.as_str())
}

/// Deja el texto listo para el sintetizador.
///
/// Se limita a quitar lo que no se pronuncia; no reescribe ni resume, porque
/// lo que suena tiene que ser lo que el modelo dijo.
pub fn clean_for_speech(text: &str) -> String {
    let mut out = String::with_capacity(text.len());
    let mut chars = text.chars().peekable();
    let mut at_line_start = true;

    while let Some(c) = chars.next() {
        match c {
            // Énfasis y código: los delimitadores se leerían en voz alta.
            '*' | '_' | '`' | '~' => continue,
            // Encabezados y viñetas, sólo al principio de línea: una
            // almohadilla o un guion en mitad de una frase sí significan algo.
            '#' if at_line_start => {
                while chars.peek() == Some(&'#') {
                    chars.next();
                }
                while chars.peek().is_some_and(|c| *c == ' ') {
                    chars.next();
                }
                continue;
            }
            '-' | '•' | '–' if at_line_start && chars.peek() == Some(&' ') => {
                chars.next();
                continue;
            }
            '>' if at_line_start => {
                while chars.peek().is_some_and(|c| *c == ' ') {
                    chars.next();
                }
                continue;
            }
            // Los saltos de línea se hablan como pausas.
            '\n' | '\r' | '\t' => {
                at_line_start = c == '\n';
                if !out.ends_with(' ') && !out.is_empty() {
                    out.push(' ');
                }
                continue;
            }
            _ => {}
        }
        at_line_start = false;
        out.push(c);
    }

    // Colapsa los espacios que deja la limpieza.
    let mut collapsed = String::with_capacity(out.len());
    let mut space = false;
    for c in out.chars() {
        if c == ' ' {
            space = true;
            continue;
        }
        if space && !collapsed.is_empty() {
            collapsed.push(' ');
        }
        space = false;
        collapsed.push(c);
    }
    collapsed.trim().to_string()
}

#[cfg(test)]
mod tests {
    use super::*;

    fn split_all(chunks: &[&str]) -> Vec<String> {
        let mut splitter = SentenceSplitter::new();
        let mut out: Vec<String> = chunks.iter().flat_map(|c| splitter.push(c)).collect();
        out.extend(splitter.flush());
        out
    }

    #[test]
    fn la_primera_frase_sale_antes_que_las_siguientes() {
        // La primera basta con que sea corta; la segunda espera a tener cuerpo.
        let out = split_all(&["Claro que sí. ", "Vale. ", "Aún no.", ""]);
        assert_eq!(out[0], "Claro que sí.");
        assert_eq!(out[1], "Vale. Aún no.");
    }

    #[test]
    fn trocea_segun_llegan_los_deltas() {
        let mut splitter = SentenceSplitter::new();
        assert!(splitter.push("Hola, ¿qué ").is_empty());