dugix 1.0.0

A local-first terminal chat app for deep research and multi-agent work
use super::*;
use dugix_core::interactive::live as data;
use dugix_core::provider::ToolDef;
use dugix_core::tools::ToolExecutor;
use ratatui::{Terminal, backend::TestBackend};
use serde_json::json;
use std::future::Future;
use std::pin::Pin;
use std::sync::{
    Arc,
    atomic::{AtomicUsize, Ordering},
};
use std::time::Instant;

const SOURCE: &str = r#"root = Panel("Live", [Text(q.text)])
q = Query("files", {action:"read",name:"a"}, {text:"Defaults"}, 15)"#;
#[derive(Default)]
struct Fake(AtomicUsize);
impl ToolExecutor for Fake {
    fn defs(&self) -> Vec<ToolDef> {
        vec![ToolDef {
            name: "files".into(),
            description: String::new(),
            parameters: json!({}),
        }]
    }
    fn is_read_only(&self, _: &str, _: &str) -> bool {
        true
    }
    fn run<'a>(
        &'a self,
        _: &'a str,
        _: &'a str,
    ) -> Pin<Box<dyn Future<Output = (String, String)> + Send + 'a>> {
        self.0.fetch_add(1, Ordering::Relaxed);
        Box::pin(std::future::ready((
            r#"{"text":"Loaded"}"#.into(),
            "ok".into(),
        )))
    }
    fn supports_images(&self) -> bool {
        false
    }
    fn space_files_dir(&self) -> Option<std::path::PathBuf> {
        None
    }
}
fn placement(complete: bool) -> Placement {
    Placement {
        row: 0,
        width: 70,
        owner: 0,
        ordinal: 0,
        height: source_height(SOURCE, 70),
        source: SOURCE.into(),
        complete,
    }
}
fn draw(widgets: &mut Widgets, placement: &Placement, top: usize) {
    Terminal::new(TestBackend::new(80, 24))
        .unwrap()
        .draw(|frame| {
            widgets.begin_frame(false);
            widgets.paint(
                frame,
                frame.area(),
                top,
                &[placement.clone()],
                &Theme::default(),
                true,
            );
        })
        .unwrap();
}
fn snapshot(entry: &Entry) -> Vec<String> {
    let (buffer, _) = entry.canvas(44, &Theme::default(), false, false);
    let body: Vec<_> = (1..buffer.area.height - 1)
        .map(|y| {
            (1..buffer.area.width - 1)
                .map(|x| buffer[(x, y)].symbol())
                .collect::<String>()
                .trim()
                .to_string()
        })
        .filter(|line| !line.is_empty())
        .collect();
    let bottom = (0..buffer.area.width)
        .map(|x| buffer[(x, buffer.area.height - 1)].symbol())
        .collect::<String>();
    let hint = bottom
        .trim_matches(|ch: char| ch.is_whitespace() || "╰╯─".contains(ch))
        .to_string();
    body.into_iter().chain([hint]).collect()
}

#[tokio::test]
async fn loading_and_loaded_query_panel_snapshots() {
    let mut session = Session::new(Document::parse(SOURCE).unwrap()).unwrap();
    let now = Instant::now();
    session.load_data(now);
    let call = session.next_data_call(now, &mut 0).unwrap().unwrap();
    let mut entry = Entry::new(Ok(session));
    assert_eq!(snapshot(&entry), ["Defaults", "Loading data"]);
    let outcome = data::execute(
        &call,
        "p1-1",
        Arc::new(Fake::default()),
        None,
        &dugix_core::trace::Scrubber::new(Vec::new()),
    )
    .await;
    entry
        .session
        .as_mut()
        .unwrap()
        .finish_data_call(&call, &outcome, now)
        .unwrap();
    assert_eq!(snapshot(&entry), ["Loaded", "F2 keyboard"]);
}

#[tokio::test]
async fn view_scheduler_keeps_streams_and_restored_panels_inert_pauses_and_logs_cards() {
    let root = std::env::temp_dir().join(format!("dugix-live-data-{}", uuid::Uuid::new_v4()));
    let core = dugix_core::app::App::new(
        dugix_core::db::Db::open_in_memory().unwrap(),
        None,
        dugix_core::space::Space { root: root.clone() },
    );
    let mut app = AppView::new(core);
    let row = app
        .db
        .create_session("data", "model", &app.active_space.id, "chat")
        .unwrap();
    app.core.switch_to_session_by_id(&row.id).unwrap();
    let executor = Arc::new(Fake::default());
    app.core.toolbox = executor.clone();
    let preview = placement(false);
    draw(&mut app.interactive, &preview, 0);
    live::tick(&mut app);
    assert!(app.interactive.entries.is_empty());
    let panel = placement(true);
    draw(&mut app.interactive, &panel, 0);
    live::tick(&mut app);
    assert_eq!(
        executor.0.load(Ordering::Relaxed),
        0,
        "restored panels need user activation"
    );
    assert!(app.interactive.focus_latest());
    app.interactive.window_focus(false);
    live::tick(&mut app);
    assert!(app.interactive.data_running.is_none());
    app.interactive.window_focus(true);
    app.interactive.unfocus();
    draw(&mut app.interactive, &panel, 100);
    live::tick(&mut app);
    assert!(
        app.interactive.data_running.is_none(),
        "off-screen queries pause"
    );
    draw(&mut app.interactive, &panel, 0);
    live::tick(&mut app);
    assert!(app.interactive.data_running.is_some());
    live::tick(&mut app);
    for _ in 0..4 {
        tokio::task::yield_now().await;
    }
    live::tick(&mut app);
    assert_eq!(
        executor.0.load(Ordering::Relaxed),
        1,
        "only one call may run at once"
    );
    assert!(app.interactive.data_running.is_none());
    let cards: Vec<_> = app
        .messages
        .iter()
        .filter(|m| m.role == "tool_call")
        .collect();
    assert_eq!(cards.len(), 1);
    let content: serde_json::Value = serde_json::from_str(&cards[0].content).unwrap();
    assert_eq!(content["panel"], "p1-1");
    assert_eq!(content["name"], "files");
    assert!(content["result"].as_str().unwrap().contains("Loaded"));
    assert_eq!(
        app.db
            .load_messages(&row.id)
            .unwrap()
            .iter()
            .filter(|m| m.role == "tool_call")
            .count(),
        1
    );
    assert_eq!(
        snapshot(&app.interactive.entries[&panel.key()]),
        ["Loaded", "F2 keyboard"]
    );
    app.interactive.clear();
    assert_eq!(
        app.interactive.data_calls[&row.id], 1,
        "viewport resets cannot reset the session budget"
    );
    drop(app);
    if root.exists() {
        std::fs::remove_dir_all(root).unwrap();
    }
}