ai-dispatch 10.26.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

// Parses the explicit checklist response contract injected into task prompts.
// Exports checklist results used for reporting and optional retries.
// Deps: standard string processing only.

pub(crate) struct ChecklistItemResult {
    pub item: String,
    pub status: ChecklistItemStatus,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ChecklistItemStatus {
    Confirmed,
    Rejected,
    Missing,
}

pub(crate) struct ChecklistResult {
    pub items: Vec<ChecklistItemResult>,
}

impl ChecklistResult {
    pub fn all_addressed(&self) -> bool {
        self.items
            .iter()
            .all(|item| item.status != ChecklistItemStatus::Missing)
    }

    pub fn missing_items(&self) -> Vec<&str> {
        self.items
            .iter()
            .filter(|item| item.status == ChecklistItemStatus::Missing)
            .map(|item| item.item.as_str())
            .collect()
    }

    pub fn summary(&self) -> String {
        let total = self.items.len();
        let confirmed = self
            .items
            .iter()
            .filter(|item| item.status == ChecklistItemStatus::Confirmed)
            .count();
        let rejected = self
            .items
            .iter()
            .filter(|item| item.status == ChecklistItemStatus::Rejected)
            .count();
        format!(
            "{}/{} addressed ({} confirmed, {} rejected)",
            confirmed + rejected,
            total,
            confirmed,
            rejected
        )
    }
}

pub(crate) fn scan_checklist(items: &[String], output: &str) -> ChecklistResult {
    ChecklistResult {
        items: items
            .iter()
            .enumerate()
            .map(|(index, item)| ChecklistItemResult {
                item: item.clone(),
                status: explicit_status(index + 1, output),
            })
            .collect(),
    }
}

fn explicit_status(number: usize, output: &str) -> ChecklistItemStatus {
    let prefix = format!("checklist {number}:");
    output
        .lines()
        .find_map(|line| status_after_prefix(line.trim(), &prefix))
        .unwrap_or(ChecklistItemStatus::Missing)
}

fn status_after_prefix(line: &str, prefix: &str) -> Option<ChecklistItemStatus> {
    let lower = line.to_ascii_lowercase();
    let rest = lower.strip_prefix(prefix)?.trim_start();
    let status = rest.split_whitespace().next()?.trim_end_matches([':', '-', '—']);
    match status {
        "confirmed" => Some(ChecklistItemStatus::Confirmed),
        "rejected" => Some(ChecklistItemStatus::Rejected),
        _ => None,
    }
}

#[cfg(test)]
#[path = "checklist_scan_tests.rs"]
mod tests;