use std::path::PathBuf;use std::time::Duration; use ai::index::full_source_code_embedding::manager::CodebaseIndexManager;use settings::Setting;use warpui::integration::{AssertionOutcome, StepData, TestStep};use warpui::{App, ReadModel, SingletonEntity, UpdateModel, WindowId, async_assert}; use crate::integration_testing::step::new_step_with_default_assertions;use crate::settings::CodeSettings;use crate::workspace::ActiveSession; const SYNC_DEFAULT_TIMEOUT: Duration = Duration::from_secs(15 * 60);const CWD_DATA_KEY: &str = "cwd"; fn active_session_cwd(app: &App, window_id: WindowId) -> Option<PathBuf> {    app.read_model(&ActiveSession::handle(app), |active_session, _ctx| {        active_session            .path_if_local(window_id)            .map(|path| path.to_path_buf())    })} /// Attempts to sync the git repo at the current working directory of the active/// session.////// Assumes that the active session is in a git repo. If not, the step will/// pass.pub fn sync_current_codebase_index() -> TestStep {    new_step_with_default_assertions("Sync current codebase index")        .set_timeout(SYNC_DEFAULT_TIMEOUT)        .add_assertion(move |app, _window_id| {            app.read_model(&CodeSettings::handle(app), |code_settings, _ctx| {                async_assert!(                    *code_settings.codebase_context_enabled.value(),                    "Codebase context should be enabled"                )            })        })        .add_assertion(move |app, window_id| {            let Some(cwd) = active_session_cwd(app, window_id) else {                return AssertionOutcome::failure(                    "Expected active session to have a cwd".to_string(),                );            };            let Ok(canonicalized_path) = dunce::canonicalize(&cwd) else {                return AssertionOutcome::failure(format!(                    "Failed to canonicalize repo path: {}",                    cwd.display()                ));            };             // Kick off codebase indexing at the current directory.            app.update_model(&CodebaseIndexManager::handle(app), |manager, ctx| {                manager.index_directory(canonicalized_path.clone(), ctx);            });             AssertionOutcome::SuccessWithData(StepData::new(                CWD_DATA_KEY.to_string(),                canonicalized_path,            ))        })        .add_named_assertion_with_data_from_prior_step(            "Assert that codebase index has been synced",            |app, _window_id, step_data_map| {                let cwd = step_data_map                    .get::<String, PathBuf>(CWD_DATA_KEY.into())                    .expect("No cwd");                 let status = app.read_model(&CodebaseIndexManager::handle(app), |manager, ctx| {                    manager.get_codebase_index_status_for_path(cwd, ctx)                });                match status {                    Some(status) => {                        async_assert!(                            status.has_synced_version()                                && status.last_sync_successful().unwrap_or(false),                            "Codebase index for {} should be synced and successful",                            cwd.display()                        )                    }                    // If the index hasn't been created, then we are not in a git repo.                    // Mark as success to avoid failing evals that are not in git repos.                    None => AssertionOutcome::Success,                }            },        )}