bmo 0.6.0

Local-first SQLite-backed CLI issue tracker for AI agents
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

use crate::model::{IssueFilter, Kind, Priority, Status};

/// Build an IssueFilter from CLI string arguments.
#[derive(Debug, Default)]
pub struct FilterBuilder {
    pub statuses: Vec<String>,
    pub priorities: Vec<String>,
    pub kinds: Vec<String>,
    pub assignee: Option<String>,
    pub labels: Vec<String>,
    pub parent_id: Option<String>,
    pub search: Option<String>,
    pub limit: usize,
    pub offset: usize,
    /// When `true`, removes the default `status != 'done'` exclusion.
    /// All other active filters (priority, kind, assignee, labels, etc.) remain in effect.
    /// Distinct from `findall` which bypasses ALL predicates.
    pub include_done: bool,
    // --all is a short-circuit that ignores all other filters and selects all issues.
    pub findall: bool,
}

impl FilterBuilder {
    pub fn build(self) -> anyhow::Result<IssueFilter> {
        let status = if self.statuses.is_empty() {
            None
        } else {
            Some(
                self.statuses
                    .iter()
                    .map(|s| s.parse::<Status>())
                    .collect::<anyhow::Result<Vec<_>>>()?,
            )
        };

        let priority = if self.priorities.is_empty() {
            None
        } else {
            Some(
                self.priorities
                    .iter()
                    .map(|p| p.parse::<Priority>())
                    .collect::<anyhow::Result<Vec<_>>>()?,
            )
        };

        let kind = if self.kinds.is_empty() {
            None
        } else {
            Some(
                self.kinds
                    .iter()
                    .map(|k| k.parse::<Kind>())
                    .collect::<anyhow::Result<Vec<_>>>()?,
            )
        };

        let parent_id = self
            .parent_id
            .as_deref()
            .map(crate::cli::parse_id)
            .transpose()?;

        let labels = if self.labels.is_empty() {
            None
        } else {
            Some(self.labels)
        };

        Ok(IssueFilter {
            status,
            priority,
            kind,
            assignee: self.assignee,
            labels,
            parent_id,
            search: self.search,
            limit: if self.limit == 0 {
                None
            } else {
                Some(self.limit)
            },
            offset: if self.offset == 0 {
                None
            } else {
                Some(self.offset)
            },
            order_by: None,
            include_done: self.include_done,
            findall: self.findall,
        })
    }
}