tea-cli 0.1.0

Interactive and headless Coding CLI for tea-rs
Documentation
use std::collections::BTreeMap;
use std::fs;
use std::io;
use std::str::FromStr as _;
use std::sync::Arc;

use clap::Parser as _;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use tea_cli::args::{CliArgs, SessionSelection};
use tea_cli::session_views::{
    MAX_SNAPSHOT_PAGE_RECORDS, session_list, session_tree, snapshot_page,
};
use tea_cli::tui::{FrameSink, InputEvent, MemoryClipboard, TuiState, run_with_channels};
use tea_cli::{BootstrapEnvironment, CliBootstrap};
use tea_model::{ModelCapabilities, ModelDisplayName, ModelSpec, ProviderId};
use tea_protocol::{ModelId, TokenCount};
use tea_session::{InMemorySessionStore, SessionArchive, SessionCatalogEntry, SessionStore};
use tea_testkit::{ScriptedModelProvider, ScriptedModelResponse};

async fn fixture_snapshot() -> tea_session::SessionSnapshot {
    let archive = SessionArchive::decode_json(include_str!(
        "../../tea-session/tests/fixtures/v1/session-archive.json"
    ))
    .unwrap();
    let session_id = archive.session_id();
    let store = InMemorySessionStore::new();
    archive.import_into(&store).await.unwrap();
    store.load(session_id).await.unwrap()
}

#[tokio::test(flavor = "current_thread")]
async fn catalog_and_tree_views_are_stable_host_projections() {
    let snapshot = fixture_snapshot().await;
    let entry = SessionCatalogEntry::from_snapshot(&snapshot, None).unwrap();
    let list = session_list(&[entry]);
    assert_eq!(list.len(), 1);
    assert_eq!(list[0].session_id(), snapshot.state().session_id());
    assert_eq!(list[0].message_count(), snapshot.state().messages().len());

    let tree = session_tree(&snapshot);
    assert!(!tree.branches().is_empty());
    assert_eq!(
        tree.branches()
            .iter()
            .filter(|branch| branch.is_active())
            .count(),
        1
    );
    let json = serde_json::to_value(&tree).unwrap();
    assert_eq!(json["sessionId"], snapshot.state().session_id().to_string());
    assert!(json.get("branches").is_some());
}

#[tokio::test(flavor = "current_thread")]
async fn snapshot_replay_is_cursor_based_and_page_bounded() {
    let snapshot = fixture_snapshot().await;
    let first = snapshot_page(&snapshot, None, 1);
    assert_eq!(first.records().len(), 1);
    assert_eq!(first.has_more(), snapshot.records().len() > 1);

    let cursor = first.records()[0].sequence();
    let rest = snapshot_page(&snapshot, Some(cursor), usize::MAX);
    assert!(rest.records().len() <= MAX_SNAPSHOT_PAGE_RECORDS);
    assert!(
        rest.records()
            .iter()
            .all(|record| record.sequence() > cursor)
    );
}

#[derive(Debug, Default)]
struct Frames;

impl FrameSink for Frames {
    fn render(&mut self, _state: &TuiState, _cursor_byte: usize) -> io::Result<()> {
        Ok(())
    }
}

#[tokio::test(flavor = "current_thread")]
async fn live_service_rebind_preserves_session_scoped_ephemeral_queue() {
    let root = std::env::temp_dir().join(format!(
        "tea-session-ux-{}",
        uuid::Uuid::now_v7().hyphenated()
    ));
    fs::create_dir_all(&root).unwrap();
    let provider_id = ProviderId::from_str("fake").unwrap();
    let provider = Arc::new(ScriptedModelProvider::new(
        provider_id.clone(),
        vec![
            ModelSpec::new(
                ModelId::from_str("fake/model").unwrap(),
                provider_id,
                ModelDisplayName::from_str("Fake Model").unwrap(),
                TokenCount::new(32_000).unwrap(),
                TokenCount::new(4_000).unwrap(),
                ModelCapabilities::text().with_tools(true),
            )
            .unwrap(),
        ],
        [ScriptedModelResponse::await_cancellation()],
    ));
    let args = CliArgs::try_parse_from([
        "tea",
        "--no-session",
        "--provider",
        "fake",
        "--model",
        "fake/model",
        "--trust",
        "ignore",
        "--cwd",
        root.to_str().unwrap(),
        "--config-dir",
        root.join("config").to_str().unwrap(),
        "--state-dir",
        root.join("state").to_str().unwrap(),
        "--data-dir",
        root.join("data").to_str().unwrap(),
    ])
    .unwrap();
    let bootstrap = CliBootstrap::new(BootstrapEnvironment::new(
        &root,
        Some(root.clone()),
        BTreeMap::new(),
    ))
    .with_provider(provider);
    let (service, _) = bootstrap.build(&args).unwrap();
    let original = service.create_session().await.unwrap();
    let (sender, receiver) = tokio::sync::mpsc::channel(32);
    let producer = tokio::spawn(async move {
        for input in [
            InputEvent::Paste("initial".to_owned()),
            InputEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
        ] {
            sender.send(input).await.unwrap();
        }
        for _ in 0..32 {
            tokio::task::yield_now().await;
        }
        for input in [
            InputEvent::Paste("steering".to_owned()),
            InputEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
            InputEvent::Paste("/new".to_owned()),
            InputEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
            InputEvent::Paste(format!("/resume {original}")),
            InputEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
            InputEvent::Key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL)),
        ] {
            sender.send(input).await.unwrap();
            tokio::task::yield_now().await;
        }
    });
    let mut frames = Frames;
    let mut clipboard = MemoryClipboard::default();
    let state = Box::pin(run_with_channels(
        &service,
        SessionSelection::Existing(original),
        receiver,
        &mut frames,
        &mut clipboard,
        None,
    ))
    .await
    .unwrap();
    producer.await.unwrap();
    assert_eq!(state.session_id(), original);
    assert_eq!(state.queued_message_count(), 1);
    service.shutdown().await;
    fs::remove_dir_all(root).unwrap();
}