dugix 1.0.0

A local-first terminal chat app for deep research and multi-agent work
//! The shared popup pattern, as Settings, Login, Local models, Copy, Connectors and Swarm follow it.
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use dugix_core::app::Popup;

use super::tests::{render_to_string, test_app};

fn assert_frame(screen: &str, title: &str, count: &str, escape: &str) {
    let top = screen.lines().find(|line| line.contains('╭')).unwrap();
    let bottom = screen.lines().find(|line| line.contains('╰')).unwrap();
    assert!(top.contains(&format!(" {title} ")), "{screen}");
    if !count.is_empty() {
        assert!(top.contains(&format!(" {count} ")), "{screen}");
        assert!(!bottom.contains(count), "{screen}");
    }
    assert!(
        bottom
            .split('╯')
            .next()
            .unwrap()
            .trim_end()
            .ends_with(escape),
        "{screen}"
    );
    for old in ["Ctrl+", "⏎", "esc"] {
        assert!(!screen.contains(old), "{old}: {screen}");
    }
}

#[test]
fn settings_uses_the_shared_frame_and_never_nerd_config() {
    let mut app = test_app();
    app.settings.show_stats = true;
    app.core.verbosity = "normal".into();
    app.open_settings();
    let screen = render_to_string(110, 30, |f| super::settings::render(f, &app));
    let count = format!("{} settings", dugix_core::app::SettingsField::ALL.len());
    assert_frame(&screen, "Settings", &count, "Esc close");
    assert!(!screen.contains("nerd config"), "{screen}");
    assert!(screen.contains("● on"), "{screen}");
    assert!(screen.contains("‹ normal ›"), "{screen}");
}

#[test]
fn login_uses_the_shared_frame_and_j_k_move_the_selection() {
    let mut app = test_app();
    app.open_login_popup();
    let screen = render_to_string(110, 30, |f| super::login::render(f, &app));
    assert_frame(&screen, "Login", "1 of 6 set", "Esc close");
    super::login::handle_key(&mut app, KeyCode::Char('j').into());
    assert_eq!(app.login_selected, 1);
    super::login::handle_key(&mut app, KeyCode::Char('k').into());
    assert_eq!(app.login_selected, 0);
    super::login::handle_key(&mut app, KeyCode::End.into());
    assert_eq!(app.login_selected, 5);
    super::login::handle_key(&mut app, KeyCode::PageUp.into());
    assert_eq!(app.login_selected, 0);
    super::login::handle_key(&mut app, KeyCode::PageDown.into());
    assert_eq!(app.login_selected, 5);
    super::login::handle_key(&mut app, KeyCode::Home.into());
    assert_eq!(app.login_selected, 0);
}

#[test]
fn local_models_uses_the_shared_frame_and_names_runtime_statuses() {
    use dugix_core::provider::local::LocalRuntime;
    use dugix_core::provider::serve::RuntimeStatus;
    let mut app = test_app();
    app.popup = Popup::Local;
    app.local.status = vec![RuntimeStatus {
        runtime: LocalRuntime::Ollama,
        endpoint: "http://localhost:11434/v1".into(),
        port: Some(11434),
        running: true,
        managed: false,
        rss_kb: None,
        over_budget: false,
        budget_kb: None,
    }];
    let screen = render_to_string(110, 30, |f| super::local::render(f, &app));
    assert_frame(&screen, "Local models", "1 running", "Esc close");
    assert!(screen.contains("● running"), "{screen}");
    assert!(screen.contains("○ stopped"), "{screen}");
    super::local::handle_key(&mut app, KeyCode::Char('j').into());
    assert_eq!(app.local_selected, 1);
    super::local::handle_key(&mut app, KeyCode::Char('k').into());
    assert_eq!(app.local_selected, 0);
    app.local.status.clear();
    app.local_from_login = true;
    let screen = render_to_string(110, 30, |f| super::local::render(f, &app));
    assert_frame(&screen, "Local models", "", "Esc back");
    assert!(
        !screen
            .lines()
            .find(|line| line.contains('╭'))
            .unwrap()
            .contains("running")
    );
}

#[test]
fn copy_uses_the_shared_frame_and_the_new_empty_sentence() {
    let mut app = test_app();
    app.copy_options = vec![dugix_core::app::CopyOption {
        label: "Copy message".into(),
        text: "message".into(),
    }];
    let screen = render_to_string(110, 30, |f| super::copy::render(f, &app));
    assert_frame(&screen, "Copy", "1 item", "Esc close");
    assert!(screen.contains("↑↓ · Enter copy · Esc close"), "{screen}");
    app.copy_options.clear();
    let screen = render_to_string(110, 30, |f| super::copy::render(f, &app));
    assert_frame(&screen, "Copy", "0 items", "Esc close");
    assert!(screen.contains("Nothing to copy here yet."), "{screen}");
    assert!(!screen.contains("Enter copy"), "{screen}");
}

#[test]
fn connectors_uses_the_shared_frame_and_requires_ctrl_d_twice() {
    use super::connectors::Mode;
    use dugix_core::connectors::{ConnectorConfig, Status};
    let mut app = test_app();
    app.connectors
        .add("notes", ConnectorConfig::local(vec!["notes".into()]))
        .unwrap();
    app.connectors
        .force_state("notes", Status::Connected { tools: 1 }, Vec::new());
    super::connectors::open(&mut app);
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Connectors", "1 connector · 1 tool", "Esc close");
    assert!(screen.contains("Enter tools · a add"), "{screen}");
    assert!(screen.contains("^D remove · Esc close"), "{screen}");
    super::connectors::handle_key(&mut app, KeyCode::Char('d').into());
    assert_eq!(app.connectors_popup.mode, Mode::List);
    let remove = KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL);
    super::connectors::handle_key(&mut app, remove);
    assert_eq!(app.connectors_popup.mode, Mode::ConfirmRemove);
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Remove connector?", "", "Esc cancel");
    assert!(
        screen.contains("“notes” and its keychain entries will be removed."),
        "{screen}"
    );
    assert!(screen.contains("^D remove · Esc cancel"), "{screen}");
    super::connectors::handle_key(&mut app, KeyCode::Char('y').into());
    assert_eq!(app.connectors_popup.mode, Mode::ConfirmRemove);
    assert_eq!(app.connectors.infos().len(), 1);
    super::connectors::handle_key(&mut app, KeyCode::Esc.into());
    assert_eq!(app.connectors_popup.mode, Mode::List);
    super::connectors::handle_key(&mut app, remove);
    super::connectors::handle_key(&mut app, remove);
    assert!(app.connectors.infos().is_empty());
    assert_eq!(app.connectors_popup.mode, Mode::List);
}

#[test]
fn swarm_uses_the_shared_frame_and_plain_n_starts_a_persona() {
    use dugix_core::app::{PendingEditor, SwarmPopupMode};
    let mut app = test_app();
    app.popup = Popup::Swarm;
    app.swarm.cache.push(dugix_core::db::Persona {
        name: "Reviewer".into(),
        model: "test-model".into(),
        blurb: "Reviews work".into(),
    });
    let screen = render_to_string(110, 30, |f| super::swarm::render(f, &app));
    assert_frame(&screen, "Swarm", "off · 1 drafter", "Esc close");
    assert!(screen.contains("Enter edit · n add"), "{screen}");
    let remove = KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL);
    super::swarm::handle_key(&mut app, remove).unwrap();
    let screen = render_to_string(110, 30, |f| super::swarm::render(f, &app));
    assert_frame(&screen, "Remove drafter?", "", "Esc cancel");
    assert!(
        screen.contains("“Reviewer” will be removed from the swarm."),
        "{screen}"
    );
    super::swarm::handle_key(&mut app, KeyCode::Char('y').into()).unwrap();
    assert!(app.swarm_popup_mode == SwarmPopupMode::ConfirmDelete);
    super::swarm::handle_key(&mut app, KeyCode::Esc.into()).unwrap();
    app.swarm.cache.clear();
    let screen = render_to_string(110, 30, |f| super::swarm::render(f, &app));
    assert_frame(&screen, "Swarm", "off · 0 drafters", "Esc close");
    assert!(
        screen.contains(
            "No drafters set, so each message gets 3 plain drafts. n adds one with a focus."
        ),
        "{screen}"
    );
    super::swarm::handle_key(
        &mut app,
        KeyEvent::new(KeyCode::Char('n'), KeyModifiers::CONTROL),
    )
    .unwrap();
    assert!(app.pending_editor.is_none());
    assert!(app.swarm.cache.is_empty());
    super::swarm::handle_key(&mut app, KeyCode::Char('n').into()).unwrap();
    assert_eq!(app.swarm.cache.len(), 1);
    assert_eq!(app.swarm_selected, 0);
    let Some(PendingEditor::Persona(path)) = app.pending_editor.take() else {
        panic!("n must queue the persona editor");
    };
    assert!(
        std::fs::read_to_string(&path)
            .unwrap()
            .starts_with("name: \n")
    );
    std::fs::remove_file(path).unwrap();
}

#[test]
fn settings_numeric_drafts_have_a_field_and_save_or_cancel_without_closing() {
    use dugix_core::app::{SettingsField, SettingsRow};
    let mut app = test_app();
    app.open_settings();
    app.settings_selected = app
        .settings_rows()
        .iter()
        .position(|row| *row == SettingsRow::Field(SettingsField::Temperature))
        .unwrap();
    super::settings::handle_key(&mut app, KeyCode::Char('1').into()).unwrap();
    let screen = render_to_string(110, 30, |f| super::settings::render(f, &app));
    assert_frame(&screen, "Settings", "18 settings", "Esc cancel");
    assert!(screen.contains("✎ 1▏"), "{screen}");
    assert!(screen.contains("Enter save · Esc cancel"), "{screen}");
    let selected = app.settings_selected;
    super::settings::handle_key(&mut app, KeyCode::Char('j').into()).unwrap();
    assert_eq!(app.settings_selected, selected);
    assert_eq!(app.settings_inputs[0], "1");
    super::settings::handle_key(&mut app, KeyCode::Esc.into()).unwrap();
    assert_eq!(app.settings_inputs[0], "");
    assert_eq!(app.popup, Popup::Settings);
    super::settings::handle_key(&mut app, KeyCode::Char('1').into()).unwrap();
    super::settings::handle_key(&mut app, KeyCode::Enter.into()).unwrap();
    assert_eq!(app.settings.temperature, Some(1.0));
    assert_eq!(app.popup, Popup::Settings);
    super::settings::handle_key(&mut app, KeyCode::Esc.into()).unwrap();
    assert_eq!(app.popup, Popup::None);
}

#[test]
fn connector_wizard_uses_step_counts_fields_and_contextual_actions() {
    use super::connectors::{AddStep, Mode};
    let mut app = test_app();
    super::connectors::open(&mut app);
    super::connectors::handle_key(&mut app, KeyCode::Char('a').into());
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Add connector", "step 1 of 2", "Esc cancel");
    super::connectors::paste(&mut app, "https://notes.example/mcp");
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Add connector", "step 1 of 3", "Esc cancel");
    assert!(screen.contains("✎ https://notes.example/mcp▏"), "{screen}");
    super::connectors::handle_key(&mut app, KeyCode::Enter.into());
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Add connector", "step 2 of 3", "Esc back");
    super::connectors::handle_key(&mut app, KeyCode::Char('j').into());
    assert_eq!(app.connectors_popup.add.name, "notesj");
    super::connectors::handle_key(&mut app, KeyCode::Enter.into());
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Add connector", "step 3 of 3", "Esc back");
    assert!(
        screen.contains("Enter save · Tab switch · Esc back"),
        "{screen}"
    );
    super::connectors::handle_key(&mut app, KeyCode::Tab.into());
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Add connector", "step 3 of 4", "Esc back");
    super::connectors::handle_key(&mut app, KeyCode::Enter.into());
    assert_eq!(app.connectors_popup.add.step, AddStep::Token);
    super::connectors::paste(&mut app, "fake-secret");
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Add connector", "step 4 of 4", "Esc back");
    assert!(screen.contains("✎ ***********▏"), "{screen}");
    assert!(!screen.contains("fake-secret"), "{screen}");
    for _ in 0..4 {
        super::connectors::handle_key(&mut app, KeyCode::Esc.into());
    }
    assert_eq!(app.connectors_popup.mode, Mode::List);
}

#[test]
fn connector_log_and_import_use_the_shared_frame_and_navigation() {
    use super::connectors::Mode;
    let mut app = test_app();
    app.connectors
        .add(
            "notes",
            dugix_core::connectors::ConnectorConfig::local(vec!["notes".into()]),
        )
        .unwrap();
    app.connectors_popup.mode = Mode::Log;
    app.connectors_popup.log = "First line\nSecond line\nLast line".into();
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "notes log", "", "Esc back");
    assert!(screen.contains("↑↓ scroll · Esc back"), "{screen}");
    super::connectors::handle_key(&mut app, KeyCode::Char('j').into());
    assert_eq!(app.connectors_popup.log_scroll, 1);
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert!(!screen.contains("First line"), "{screen}");
    assert!(screen.contains("Second line"), "{screen}");
    super::connectors::handle_key(&mut app, KeyCode::Char('k').into());
    assert_eq!(app.connectors_popup.log_scroll, 0);
    super::connectors::handle_key(&mut app, KeyCode::End.into());
    assert_eq!(app.connectors_popup.log_scroll, 2);
    super::connectors::handle_key(&mut app, KeyCode::Home.into());
    assert_eq!(app.connectors_popup.log_scroll, 0);
    super::connectors::handle_key(&mut app, KeyCode::Esc.into());
    assert_eq!(app.connectors_popup.mode, Mode::List);
    app.connectors_popup.mode = Mode::Import;
    let screen = render_to_string(110, 30, |f| super::connectors::render(f, &app));
    assert_frame(&screen, "Import connectors", "0 selected", "Esc back");
    assert!(
        screen.contains("Space toggle · a all · Enter import · Esc back"),
        "{screen}"
    );
}