magi-code 0.104.0

Repository-aware CLI coding agent for terminal work
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use super::*;
use std::time::Instant;

/// Times session listing, reading and history hydration against a copied store.
/// Set `PROFILE_SESSION_STORE` to a disposable copy; listing may rebuild stale sidecars there.
#[test]
#[ignore = "session load measurement; run with --release --ignored --nocapture and PROFILE_SESSION_STORE"]
fn session_store_load_measurement() {
    let Ok(root) = std::env::var("PROFILE_SESSION_STORE") else {
        eprintln!("session_load skipped: PROFILE_SESSION_STORE unset");
        return;
    };
    let manager = SessionManager::new(root.into());
    // "first" may rebuild stale sidecars in the copied store; "repeat" reuses them.
    for pass in ["first", "repeat"] {
        let started = Instant::now();
        let summaries = manager.list_metadata_summaries().unwrap();
        eprintln!(
            "session_list pass={pass} sessions={} elapsed_ms={:.2}",
            summaries.len(),
            started.elapsed().as_secs_f64() * 1000.0
        );
    }
    if let Some(newest) = manager.list_metadata_summaries().unwrap().last() {
        let started = Instant::now();
        let session = manager.open_existing(newest.session.id()).unwrap();
        let _ = crate::sessions::session_title_metadata(&session).unwrap();
        eprintln!(
            "session_title_lookup elapsed_ms={:.3}",
            started.elapsed().as_secs_f64() * 1000.0
        );
    }
    let mut sessions = manager
        .list_metadata_summaries()
        .unwrap()
        .into_iter()
        .map(|summary| summary.session)
        .collect::<Vec<_>>();
    sessions.sort_by_key(|session| {
        std::cmp::Reverse(fs::metadata(session.path()).map(|m| m.len()).unwrap_or(0))
    });
    let settings = crate::config::InjectedContentSettings::default();
    for session in sessions.iter().take(5) {
        let file_bytes = fs::metadata(session.path()).map(|m| m.len()).unwrap_or(0);
        let read_started = Instant::now();
        let read = match session
            .read_events_tolerant_bounded(SESSION_SWITCH_MAX_EVENTS, SESSION_SWITCH_MAX_BYTES)
        {
            Ok(read) => read,
            Err(_) => {
                // Error text may name private paths; switch rejects these sessions too.
                eprintln!("session_load file_bytes={file_bytes} skipped=read_rejected");
                continue;
            }
        };
        let read_ms = read_started.elapsed().as_secs_f64() * 1000.0;
        let hydrate_started = Instant::now();
        let snapshot = hydrate_session_history_snapshot(&read.events, &settings);
        let hydrate_ms = hydrate_started.elapsed().as_secs_f64() * 1000.0;
        eprintln!(
            "session_load file_bytes={file_bytes} events={} transcript={} read_ms={read_ms:.2} hydrate_ms={hydrate_ms:.2}",
            read.events.len(),
            snapshot.transcript.len(),
        );
    }
}