mi6_tui/

lib.rs

//! mi6 - A top-like CLI for monitoring agentic coding sessions.

#![allow(clippy::print_stdout, clippy::print_stderr)]
// Test code can use unwrap/panic/etc. freely - these are fine in tests
#![cfg_attr(
    test,
    expect(
        clippy::unwrap_used,
        clippy::panic,
        clippy::approx_constant,
        clippy::field_reassign_with_default
    )
)]

mod app;
mod domain;
mod infra;
mod render;

use domain::stored_config::Config as StoredConfig;

// Public API: Only expose what the binary crate needs
pub use domain::{SessionField, parse_column_spec};

use std::io::{self, IsTerminal};
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

use anyhow::Result;
use crossterm::{
    event::{DisableMouseCapture, EnableMouseCapture},
    execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{Terminal, backend::CrosstermBackend};

use app::App;
use infra::{
    DEFAULT_REFRESH_IDX, REFRESH_INTERVALS_MS, check_and_enable_new_frameworks, find_interval_idx,
    refresh_thread, transcript_poll_thread,
};

/// CLI configuration passed from command-line arguments.
#[derive(Debug, Default, Clone)]
pub struct Config {
    /// Initial refresh interval in milliseconds.
    pub interval_ms: Option<u64>,
    /// Transcript poll interval in milliseconds.
    pub transcript_poll_ms: Option<u64>,
    /// Show all sessions including dead ones.
    pub show_all: bool,
    /// Color theme name (overrides stored config).
    pub theme: Option<String>,
    /// Column visibility override from CLI (if specified).
    pub columns: Option<Vec<bool>>,
    /// Expert mode: shows mi6 process stats in global stats panel.
    pub expert_mode: bool,
}

/// Run the mi6 TUI application.
pub fn run(config: Config) -> Result<()> {
    // Check for interactive terminal before attempting TUI setup
    if !std::io::stdout().is_terminal() {
        anyhow::bail!("mi6 requires an interactive terminal");
    }

    // Determine initial refresh interval: CLI > stored config > default
    let stored_config = StoredConfig::load();

    // Check for newly installed frameworks and enable them based on per-framework auto-enable settings.
    // Uses a lock file to coordinate between mi6 instances.
    let newly_activated = check_and_enable_new_frameworks(&stored_config.framework_auto_enable);
    if !newly_activated.is_empty() {
        eprintln!("Auto-enabled mi6 for: {}", newly_activated.join(", "));
    }

    let refresh_interval_idx = config.interval_ms.map_or_else(
        || {
            stored_config
                .refresh_interval_ms
                .map_or(DEFAULT_REFRESH_IDX, find_interval_idx)
        },
        find_interval_idx,
    );
    let initial_interval = Duration::from_millis(REFRESH_INTERVALS_MS[refresh_interval_idx]);

    // Determine initial transcript poll interval: CLI > stored config > default
    let transcript_poll_interval_idx = config.transcript_poll_ms.map_or_else(
        || {
            stored_config
                .transcript_poll_interval_ms
                .map_or(DEFAULT_REFRESH_IDX, find_interval_idx)
        },
        find_interval_idx,
    );
    let initial_transcript_poll_interval =
        Duration::from_millis(REFRESH_INTERVALS_MS[transcript_poll_interval_idx]);

    // Start background data loading FIRST - this opens DB and queries
    let (data_tx, data_rx) = mpsc::channel();
    let (interval_tx, interval_rx) = mpsc::channel();
    thread::spawn(move || {
        refresh_thread(&data_tx, &interval_rx, initial_interval);
    });

    // Start transcript poll thread with lock status reporting
    let (transcript_poll_tx, transcript_poll_rx) = mpsc::channel();
    let (lock_status_tx, lock_status_rx) = mpsc::channel();
    thread::spawn(move || {
        transcript_poll_thread(
            &transcript_poll_rx,
            &lock_status_tx,
            initial_transcript_poll_interval,
        );
    });

    // Start background update check (if enabled)
    let check_for_updates_enabled = stored_config.check_for_updates.unwrap_or(true);
    let (update_tx, update_rx) = mpsc::channel::<Vec<String>>();
    if check_for_updates_enabled {
        thread::spawn(move || {
            // Check for updates in background - errors are silently ignored
            // since this is a non-critical feature
            if let Ok(Some(update_info)) = mi6_cli::check_for_update() {
                // Send the update notifications (ignore send errors - receiver might be gone)
                let _ = update_tx.send(update_info.notification_messages());
            }
        });
    }

    // Block-wait for first data BEFORE entering alternate screen
    // This prevents the "empty frame" flash - screen switches with data ready
    let first_data = data_rx.recv_timeout(Duration::from_millis(500)).ok();

    // NOW setup terminal - user never sees empty screen
    enable_raw_mode()?;
    let mut stdout = io::stdout();
    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
    let backend = CrosstermBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

    // Build startup messages for the message log
    let mut startup_messages: Vec<String> = Vec::new();

    // Welcome message with version and git hash (if available)
    let git_hash = env!("MI6_GIT_HASH");
    if git_hash.is_empty() {
        startup_messages.push(format!("Welcome to mi6 v{}", env!("CARGO_PKG_VERSION")));
    } else {
        startup_messages.push(format!(
            "Welcome to mi6 v{} (0x{})",
            env!("CARGO_PKG_VERSION"),
            git_hash
        ));
    }

    // Auto-enabled frameworks
    for name in &newly_activated {
        startup_messages.push(format!("Auto-enabled mi6 for {name}"));
    }

    // Create app with first data already loaded
    let app = App::with_first_data(
        data_rx,
        interval_tx,
        Some(transcript_poll_tx),
        Some(lock_status_rx),
        Some(update_rx),
        first_data,
        &stored_config,
        refresh_interval_idx,
        transcript_poll_interval_idx,
        config.show_all,
        config.theme.as_deref(),
        config.columns,
        startup_messages,
        config.expert_mode,
    );

    let result = infra::run_app(&mut terminal, app);

    // Restore terminal
    disable_raw_mode()?;
    execute!(
        terminal.backend_mut(),
        LeaveAlternateScreen,
        DisableMouseCapture
    )?;
    terminal.show_cursor()?;

    if let Err(e) = result {
        eprintln!("Error: {e}");
    }

    Ok(())
}