ai-dispatch 10.20.0

Multi-AI CLI team orchestrator
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

// Classifies verification failures that come from tooling rather than the change.
// Exports: output and error infrastructure classifiers.
// Deps: anyhow and standard string processing.

pub(super) fn output_indicates_infrastructure_failure(output: &str) -> bool {
    contains_infrastructure_marker(output) && !has_compiler_or_test_diagnostic(output)
}

pub(super) fn error_indicates_infrastructure_failure(
    error: &anyhow::Error,
    containerized: bool,
) -> bool {
    let lower = error
        .chain()
        .map(|cause| cause.to_string().to_lowercase())
        .collect::<Vec<_>>()
        .join(" | ");
    lower.contains("resource temporarily unavailable")
        || lower.contains("cannot allocate memory")
        || lower.contains("verify output reader")
        || lower.contains("verify stdout pipe")
        || lower.contains("verify stderr pipe")
        || lower.contains("verify process wait")
        || (containerized
            && (lower.contains("connection refused")
                || lower.contains("cannot connect")
                || lower.contains("daemon is not running")
                || lower.contains("no such file or directory")))
}

fn contains_infrastructure_marker(output: &str) -> bool {
    let lower = output.to_lowercase();
    [
        "sccache: encountered fatal error",
        "failed to spawn command",
        "no space left on device",
        "disk quota exceeded",
        "disk space below",
        "free space below",
        "less than 10 gb free",
        "not enough free space",
        "cannot connect to the docker daemon",
        "container daemon is not running",
        "failed to connect to container",
        "container is not running",
    ]
    .iter()
    .any(|marker| lower.contains(marker))
}

fn has_compiler_or_test_diagnostic(output: &str) -> bool {
    output.lines().any(|line| {
        let lower = line.trim().to_lowercase();
        if contains_infrastructure_marker(&lower) || lower.starts_with("sccache:") {
            return false;
        }
        lower.contains("error[")
            || lower.starts_with("error:")
            || lower.starts_with("error ")
            || lower.contains("could not compile")
            || lower.contains("test result: failed")
            || lower.contains("failures:")
            || lower.contains("tests failed")
            || (lower.contains("test suites:") && lower.contains("failed"))
            || lower.contains("assertion failed")
            || lower.contains(" ... failed")
            || lower.contains("--- fail:")
            || lower.starts_with("fail ")
            || lower.starts_with("fail:")
            || lower.starts_with("fail/")
            || lower.contains("build failed")
            || lower.contains("panic:")
            || lower.contains("traceback")
            || lower.contains("syntaxerror")
    })
}

#[cfg(test)]
mod tests {
    use super::{error_indicates_infrastructure_failure, output_indicates_infrastructure_failure};

    #[test]
    fn classifies_real_sccache_spawn_failure_without_diagnostics() {
        assert!(output_indicates_infrastructure_failure(
            "sccache: encountered fatal error\nsccache: error: failed to spawn"
        ));
    }

    #[test]
    fn keeps_go_and_jest_failures_as_change_failures() {
        assert!(!output_indicates_infrastructure_failure(
            "sccache: encountered fatal error\n--- FAIL: TestThing (0.01s)"
        ));
        assert!(!output_indicates_infrastructure_failure(
            "sccache: encountered fatal error\nFAIL src/example.test.ts"
        ));
    }

    #[test]
    fn loose_disk_prose_is_not_an_infrastructure_marker() {
        assert!(!output_indicates_infrastructure_failure(
            "a test that checks free space handling"
        ));
        assert!(!output_indicates_infrastructure_failure(
            "reported disk space usage for the cache"
        ));
    }

    #[test]
    fn classifies_started_verify_reader_failure_as_infrastructure() {
        let error = anyhow::anyhow!("verify output reader thread panicked");
        assert!(error_indicates_infrastructure_failure(&error, false));
    }

    #[test]
    fn classifies_resource_errors_but_not_missing_configured_commands() {
        let eagain = anyhow::anyhow!("failed to spawn subprocess: Resource temporarily unavailable");
        let enomem = anyhow::anyhow!("failed to spawn subprocess: Cannot allocate memory");
        let missing = anyhow::anyhow!("Failed to run verify command: No such file or directory");
        assert!(error_indicates_infrastructure_failure(&eagain, false));
        assert!(error_indicates_infrastructure_failure(&enomem, false));
        assert!(!error_indicates_infrastructure_failure(&missing, false));
    }

    #[test]
    fn keeps_container_markers_gated_to_containerized_verification() {
        let error = anyhow::anyhow!("container exec: No such file or directory");
        assert!(!error_indicates_infrastructure_failure(&error, false));
        assert!(error_indicates_infrastructure_failure(&error, true));
    }
}