aprender-shell 0.31.2

AI-powered shell completion trained on your history
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

/// Test graceful handling of unicode edge cases
#[test]
fn test_cli_021_chaos_unicode() {
    let history = create_temp_history(&["git status", "cargo build"]);
    let model = NamedTempFile::new().unwrap();

    aprender_shell()
        .args([
            "train",
            "-f",
            history.path().to_str().unwrap(),
            "-o",
            model.path().to_str().unwrap(),
        ])
        .assert()
        .success();

    // Test Unicode edge cases
    let test_cases = [
        "🚀",                // Emoji
        "日本語",            // CJK characters
        "مرحبا",             // RTL text
        "\u{FEFF}git",       // BOM
        "git\u{200B}status", // Zero-width space
        "git\u{202E}status", // RTL override
        &"é".repeat(100),    // Many combining marks
    ];

    for prefix in test_cases {
        aprender_shell()
            .args(["suggest", "-m", model.path().to_str().unwrap(), prefix])
            .assert()
            .success(); // Should handle gracefully
    }
}

/// Test graceful handling of concurrent file access
#[test]
fn test_cli_021_chaos_concurrent_read() {
    use std::thread;

    let history = create_temp_history(&[
        "git status",
        "git commit",
        "git push",
        "cargo build",
        "cargo test",
    ]);
    let model = NamedTempFile::new().unwrap();

    aprender_shell()
        .args([
            "train",
            "-f",
            history.path().to_str().unwrap(),
            "-o",
            model.path().to_str().unwrap(),
        ])
        .assert()
        .success();

    let model_path = model.path().to_str().unwrap().to_string();

    // Spawn multiple concurrent readers
    let handles: Vec<_> = (0..5)
        .map(|_| {
            let model_path = model_path.clone();
            thread::spawn(move || {
                for _ in 0..10 {
                    Command::cargo_bin("aprender-shell")
                        .unwrap()
                        .args(["suggest", "-m", &model_path, "git "])
                        .assert()
                        .success();
                }
            })
        })
        .collect();

    // All threads should complete without issues
    for handle in handles {
        handle.join().expect("Thread should complete successfully");
    }
}

/// Test graceful handling of rapid sequential calls
#[test]
fn test_cli_021_chaos_rapid_calls() {
    let history = create_temp_history(&["git status", "git commit", "cargo build"]);
    let model = NamedTempFile::new().unwrap();

    aprender_shell()
        .args([
            "train",
            "-f",
            history.path().to_str().unwrap(),
            "-o",
            model.path().to_str().unwrap(),
        ])
        .assert()
        .success();

    // Rapid sequential calls
    for i in 0..50 {
        aprender_shell()
            .args([
                "suggest",
                "-m",
                model.path().to_str().unwrap(),
                &format!("git {:02}", i),
            ])
            .assert()
            .success();
    }
}